Changeset 111126 in webkit

Timestamp:

Mar 17, 2012 12:54:09 PM (12 years ago)

Author:

commit-queue@webkit.org

Message:

move calc*Value functions out from Length (and platform)
​https://bugs.webkit.org/show_bug.cgi?id=80897

Moving the Length calc*Value functions out from Length structure and also from /WebCore/platform/ folder.
This helps to avoid the layering violation while length calculation. Otherwise layer violation can be avoided only by adding a virtual interface(bug 27160).

Patch by Joe Thomas <​joethomas@motorola.com> on 2012-03-17
Reviewed by Antti Koivisto.

Source/WebCore:

• GNUmakefile.list.am: Build system changes for adding new files.
• Target.pri: Ditto.
• WebCore.gypi: Ditto.
• WebCore.vcproj/WebCore.vcproj: Ditto.
• WebCore.xcodeproj/project.pbxproj: Ditto.
• accessibility/gtk/WebKitAccessibleInterfaceText.cpp:

(getAttributeSetForAccessibilityObject):

• css/CSSComputedStyleDeclaration.cpp:

(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):

• css/LengthFunctions.h: Added. Moved calc*Value functions of Length.

(WebCore):
(WebCore::calculateMinimumValue):
(WebCore::calculateValue):
(WebCore::calculateFloatValue):

• dom/Document.cpp:

(WebCore::Document::pageSizeAndMarginsInPixels):

• html/HTMLAreaElement.cpp:

(WebCore::HTMLAreaElement::getRegion):

• platform/CalculationValue.h:

(WebCore::CalcExpressionLength::evaluate):

• platform/Length.h: Removed the calc*Value functions from Length structure.

(Length):
(WebCore::Length::getFloatValue):
(WebCore::Length::getIntValue):

• platform/graphics/ca/mac/PlatformCAAnimationMac.mm:
• platform/graphics/ca/mac/PlatformCALayerMac.mm:

(PlatformCALayer::setFilters):

• platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp:

(WebCore::CCRenderSurfaceFilters::apply):

• platform/graphics/filters/FilterOperations.cpp:

(WebCore::FilterOperations::getOutsets):

• platform/graphics/transforms/PerspectiveTransformOperation.cpp:

(WebCore::PerspectiveTransformOperation::blend):

• platform/graphics/transforms/PerspectiveTransformOperation.h:

(WebCore::PerspectiveTransformOperation::isIdentity):
(WebCore::PerspectiveTransformOperation::apply):

• platform/graphics/transforms/TranslateTransformOperation.h:

(WebCore::TranslateTransformOperation::x):
(WebCore::TranslateTransformOperation::y):
(WebCore::TranslateTransformOperation::z):
(WebCore::TranslateTransformOperation::isIdentity):

• platform/win/PopupMenuWin.cpp:

(WebCore::PopupMenuWin::paint):

• rendering/AutoTableLayout.cpp:

(WebCore::AutoTableLayout::layout):

• 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::clipRect):
(WebCore::RenderBox::computeLogicalWidthInRegion):
(WebCore::RenderBox::computeLogicalWidthInRegionUsing):
(WebCore::RenderBox::computeInlineDirectionMargins):
(WebCore::RenderBox::computePercentageLogicalHeight):
(WebCore::RenderBox::computeReplacedLogicalWidthUsing):
(WebCore::RenderBox::computeReplacedLogicalHeightUsing):
(WebCore::RenderBox::availableLogicalHeightUsing):
(WebCore::RenderBox::computeBlockDirectionMargins):
(WebCore::RenderBox::computePositionedLogicalWidthUsing):
(WebCore::RenderBox::computePositionedLogicalHeightUsing):
(WebCore::RenderBox::computePositionedLogicalWidthReplaced):
(WebCore::RenderBox::computePositionedLogicalHeightReplaced):

• rendering/RenderBoxModelObject.cpp:

(WebCore::RenderBoxModelObject::relativePositionOffsetX):
(WebCore::RenderBoxModelObject::relativePositionOffsetY):
(WebCore::RenderBoxModelObject::paddingTop):
(WebCore::RenderBoxModelObject::paddingBottom):
(WebCore::RenderBoxModelObject::paddingLeft):
(WebCore::RenderBoxModelObject::paddingRight):
(WebCore::RenderBoxModelObject::paddingBefore):
(WebCore::RenderBoxModelObject::paddingAfter):
(WebCore::RenderBoxModelObject::paddingStart):
(WebCore::RenderBoxModelObject::paddingEnd):
(WebCore::RenderBoxModelObject::calculateFillTileSize):
(WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry):
(WebCore::computeBorderImageSide):
(WebCore::RenderBoxModelObject::paintNinePieceImage):

• rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::preferredMainAxisContentExtentForChild):
(WebCore::RenderFlexibleBox::computeMainAxisPreferredSizes):
(WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm):

• rendering/RenderFrameSet.cpp:

(WebCore::RenderFrameSet::layOutAxis):

• rendering/RenderInline.cpp:

(WebCore::computeMargin):

• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::perspectiveTransform):
(WebCore::RenderLayer::perspectiveOrigin):

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::computeTransformOrigin):
(WebCore::RenderLayerBacking::computePerspectiveOrigin):

• rendering/RenderMarquee.cpp:

(WebCore::RenderMarquee::timerFired):

• rendering/RenderMenuList.cpp:

(WebCore::RenderMenuList::updateOptionsWidth):

• rendering/RenderObject.cpp:

(WebCore::RenderObject::repaintAfterLayoutIfNeeded):

• rendering/RenderReplaced.cpp:

(WebCore::RenderReplaced::computeReplacedLogicalWidth):

• rendering/RenderScrollbarPart.cpp:

(WebCore::calcScrollbarThicknessUsing):
(WebCore::RenderScrollbarPart::computeScrollbarWidth):
(WebCore::RenderScrollbarPart::computeScrollbarHeight):

• rendering/RenderTable.cpp:

(WebCore::RenderTable::computeLogicalWidth):
(WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):

• rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::logicalHeightForRowSizing):

• rendering/RenderTableSection.cpp:

(WebCore::RenderTableSection::calcRowLogicalHeight):

• rendering/RenderText.h:

(WebCore::RenderText::marginLeft):
(WebCore::RenderText::marginRight):

• rendering/RootInlineBox.cpp:

(WebCore::RootInlineBox::verticalPositionForBox):

• rendering/style/RenderStyle.cpp:

(WebCore::RenderStyle::applyTransform):
(WebCore::calcRadiiFor):

• rendering/style/RenderStyle.h:
• rendering/svg/RenderSVGRoot.cpp:

(WebCore::RenderSVGRoot::computeIntrinsicRatioInformation):
(WebCore::resolveLengthAttributeForSVG):

• svg/SVGSVGElement.cpp:

(WebCore::SVGSVGElement::currentViewBoxRect):
(WebCore::SVGSVGElement::currentViewportSize):

• svg/graphics/SVGImage.cpp:

(WebCore::SVGImage::computeIntrinsicDimensions):

Source/WebKit2:

• WebProcess/WebCoreSupport/win/WebPopupMenuWin.cpp:

(WebKit::WebPopupMenu::setUpPlatformData):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/GNUmakefile.list.am (modified) (1 diff)
• WebCore/Target.pri (modified) (1 diff)
• WebCore/WebCore.gypi (modified) (1 diff)
• WebCore/WebCore.vcproj/WebCore.vcproj (modified) (1 diff)
• WebCore/WebCore.xcodeproj/project.pbxproj (modified) (4 diffs)
• WebCore/accessibility/gtk/WebKitAccessibleInterfaceText.cpp (modified) (1 diff)
• WebCore/css/CSSComputedStyleDeclaration.cpp (modified) (3 diffs)
• WebCore/css/LengthFunctions.h (added)
• WebCore/dom/Document.cpp (modified) (2 diffs)
• WebCore/html/HTMLAreaElement.cpp (modified) (2 diffs)
• WebCore/platform/CalculationValue.h (modified) (2 diffs)
• WebCore/platform/Length.h (modified) (4 diffs)
• WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm (modified) (2 diffs)
• WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm (modified) (2 diffs)
• WebCore/platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp (modified) (2 diffs)
• WebCore/platform/graphics/filters/FilterOperations.cpp (modified) (2 diffs)
• WebCore/platform/graphics/transforms/PerspectiveTransformOperation.cpp (modified) (2 diffs)
• WebCore/platform/graphics/transforms/PerspectiveTransformOperation.h (modified) (3 diffs)
• WebCore/platform/graphics/transforms/TranslateTransformOperation.h (modified) (3 diffs)
• WebCore/platform/win/PopupMenuWin.cpp (modified) (2 diffs)
• WebCore/rendering/AutoTableLayout.cpp (modified) (1 diff)
• WebCore/rendering/FilterEffectRenderer.cpp (modified) (1 diff)
• WebCore/rendering/FixedTableLayout.cpp (modified) (1 diff)
• WebCore/rendering/RenderBlock.cpp (modified) (3 diffs)
• WebCore/rendering/RenderBox.cpp (modified) (36 diffs)
• WebCore/rendering/RenderBoxModelObject.cpp (modified) (16 diffs)
• WebCore/rendering/RenderFlexibleBox.cpp (modified) (4 diffs)
• WebCore/rendering/RenderFrameSet.cpp (modified) (1 diff)
• WebCore/rendering/RenderInline.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayer.cpp (modified) (2 diffs)
• WebCore/rendering/RenderLayerBacking.cpp (modified) (2 diffs)
• WebCore/rendering/RenderMarquee.cpp (modified) (1 diff)
• WebCore/rendering/RenderMenuList.cpp (modified) (1 diff)
• WebCore/rendering/RenderObject.cpp (modified) (2 diffs)
• WebCore/rendering/RenderReplaced.cpp (modified) (1 diff)
• WebCore/rendering/RenderScrollbarPart.cpp (modified) (3 diffs)
• WebCore/rendering/RenderTable.cpp (modified) (3 diffs)
• WebCore/rendering/RenderTableCell.cpp (modified) (1 diff)
• WebCore/rendering/RenderTableSection.cpp (modified) (1 diff)
• WebCore/rendering/RenderText.h (modified) (1 diff)
• WebCore/rendering/RootInlineBox.cpp (modified) (1 diff)
• WebCore/rendering/style/RenderStyle.cpp (modified) (5 diffs)
• WebCore/rendering/style/RenderStyle.h (modified) (2 diffs)
• WebCore/rendering/svg/RenderSVGRoot.cpp (modified) (2 diffs)
• WebCore/svg/SVGSVGElement.cpp (modified) (2 diffs)
• WebCore/svg/graphics/SVGImage.cpp (modified) (1 diff)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/WebProcess/WebCoreSupport/win/WebPopupMenuWin.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-03-17  Joe Thomas  <joethomas@motorola.com>
+
+        move calc*Value functions out from Length (and platform)
+        https://bugs.webkit.org/show_bug.cgi?id=80897
+
+        Moving the Length calc*Value functions out from Length structure and also from /WebCore/platform/ folder.
+        This helps to avoid the layering violation while length calculation. Otherwise layer violation can be avoided only by adding a virtual interface(bug 27160).
+
+        Reviewed by Antti Koivisto.
+
+        * GNUmakefile.list.am: Build system changes for adding new files.
+        * Target.pri: Ditto.
+        * WebCore.gypi: Ditto.
+        * WebCore.vcproj/WebCore.vcproj: Ditto.
+        * WebCore.xcodeproj/project.pbxproj: Ditto.
+        * accessibility/gtk/WebKitAccessibleInterfaceText.cpp:
+        (getAttributeSetForAccessibilityObject):
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
+        * css/LengthFunctions.h: Added. Moved calc*Value functions of Length.
+        (WebCore):
+        (WebCore::calculateMinimumValue):
+        (WebCore::calculateValue):
+        (WebCore::calculateFloatValue):
+        * dom/Document.cpp:
+        (WebCore::Document::pageSizeAndMarginsInPixels):
+        * html/HTMLAreaElement.cpp:
+        (WebCore::HTMLAreaElement::getRegion):
+        * platform/CalculationValue.h:
+        (WebCore::CalcExpressionLength::evaluate):
+        * platform/Length.h: Removed the calc*Value functions from Length structure.
+        (Length):
+        (WebCore::Length::getFloatValue):
+        (WebCore::Length::getIntValue):
+        * platform/graphics/ca/mac/PlatformCAAnimationMac.mm:
+        * platform/graphics/ca/mac/PlatformCALayerMac.mm:
+        (PlatformCALayer::setFilters):
+        * platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp:
+        (WebCore::CCRenderSurfaceFilters::apply):
+        * platform/graphics/filters/FilterOperations.cpp:
+        (WebCore::FilterOperations::getOutsets):
+        * platform/graphics/transforms/PerspectiveTransformOperation.cpp:
+        (WebCore::PerspectiveTransformOperation::blend):
+        * platform/graphics/transforms/PerspectiveTransformOperation.h:
+        (WebCore::PerspectiveTransformOperation::isIdentity):
+        (WebCore::PerspectiveTransformOperation::apply):
+        * platform/graphics/transforms/TranslateTransformOperation.h:
+        (WebCore::TranslateTransformOperation::x):
+        (WebCore::TranslateTransformOperation::y):
+        (WebCore::TranslateTransformOperation::z):
+        (WebCore::TranslateTransformOperation::isIdentity):
+        * platform/win/PopupMenuWin.cpp:
+        (WebCore::PopupMenuWin::paint):
+        * rendering/AutoTableLayout.cpp:
+        (WebCore::AutoTableLayout::layout):
+        * 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::clipRect):
+        (WebCore::RenderBox::computeLogicalWidthInRegion):
+        (WebCore::RenderBox::computeLogicalWidthInRegionUsing):
+        (WebCore::RenderBox::computeInlineDirectionMargins):
+        (WebCore::RenderBox::computePercentageLogicalHeight):
+        (WebCore::RenderBox::computeReplacedLogicalWidthUsing):
+        (WebCore::RenderBox::computeReplacedLogicalHeightUsing):
+        (WebCore::RenderBox::availableLogicalHeightUsing):
+        (WebCore::RenderBox::computeBlockDirectionMargins):
+        (WebCore::RenderBox::computePositionedLogicalWidthUsing):
+        (WebCore::RenderBox::computePositionedLogicalHeightUsing):
+        (WebCore::RenderBox::computePositionedLogicalWidthReplaced):
+        (WebCore::RenderBox::computePositionedLogicalHeightReplaced):
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::relativePositionOffsetX):
+        (WebCore::RenderBoxModelObject::relativePositionOffsetY):
+        (WebCore::RenderBoxModelObject::paddingTop):
+        (WebCore::RenderBoxModelObject::paddingBottom):
+        (WebCore::RenderBoxModelObject::paddingLeft):
+        (WebCore::RenderBoxModelObject::paddingRight):
+        (WebCore::RenderBoxModelObject::paddingBefore):
+        (WebCore::RenderBoxModelObject::paddingAfter):
+        (WebCore::RenderBoxModelObject::paddingStart):
+        (WebCore::RenderBoxModelObject::paddingEnd):
+        (WebCore::RenderBoxModelObject::calculateFillTileSize):
+        (WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry):
+        (WebCore::computeBorderImageSide):
+        (WebCore::RenderBoxModelObject::paintNinePieceImage):
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::preferredMainAxisContentExtentForChild):
+        (WebCore::RenderFlexibleBox::computeMainAxisPreferredSizes):
+        (WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm):
+        * rendering/RenderFrameSet.cpp:
+        (WebCore::RenderFrameSet::layOutAxis):
+        * rendering/RenderInline.cpp:
+        (WebCore::computeMargin):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::perspectiveTransform):
+        (WebCore::RenderLayer::perspectiveOrigin):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::computeTransformOrigin):
+        (WebCore::RenderLayerBacking::computePerspectiveOrigin):
+        * rendering/RenderMarquee.cpp:
+        (WebCore::RenderMarquee::timerFired):
+        * rendering/RenderMenuList.cpp:
+        (WebCore::RenderMenuList::updateOptionsWidth):
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::repaintAfterLayoutIfNeeded):
+        * rendering/RenderReplaced.cpp:
+        (WebCore::RenderReplaced::computeReplacedLogicalWidth):
+        * rendering/RenderScrollbarPart.cpp:
+        (WebCore::calcScrollbarThicknessUsing):
+        (WebCore::RenderScrollbarPart::computeScrollbarWidth):
+        (WebCore::RenderScrollbarPart::computeScrollbarHeight):
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::computeLogicalWidth):
+        (WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
+        * rendering/RenderTableCell.cpp:
+        (WebCore::RenderTableCell::logicalHeightForRowSizing):
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::calcRowLogicalHeight):
+        * rendering/RenderText.h:
+        (WebCore::RenderText::marginLeft):
+        (WebCore::RenderText::marginRight):
+        * rendering/RootInlineBox.cpp:
+        (WebCore::RootInlineBox::verticalPositionForBox):
+        * rendering/style/RenderStyle.cpp:
+        (WebCore::RenderStyle::applyTransform):
+        (WebCore::calcRadiiFor):
+        * rendering/style/RenderStyle.h:
+        * rendering/svg/RenderSVGRoot.cpp:
+        (WebCore::RenderSVGRoot::computeIntrinsicRatioInformation):
+        (WebCore::resolveLengthAttributeForSVG):
+        * svg/SVGSVGElement.cpp:
+        (WebCore::SVGSVGElement::currentViewBoxRect):
+        (WebCore::SVGSVGElement::currentViewportSize):
+        * svg/graphics/SVGImage.cpp:
+        (WebCore::SVGImage::computeIntrinsicDimensions):
+
 2012-03-17  Nikolas Zimmermann  <nzimmermann@rim.com>
 

trunk/Source/WebCore/GNUmakefile.list.am

@@ -1646 +1646 @@
         Source/WebCore/css/FontValue.cpp \
         Source/WebCore/css/FontValue.h \
+        Source/WebCore/css/LengthFunctions.h \
         Source/WebCore/css/MediaFeatureNames.cpp \
         Source/WebCore/css/MediaFeatureNames.h \

trunk/Source/WebCore/Target.pri

@@ -1610 +1610 @@
     css/FontFeatureValue.h \
     css/FontValue.h \
+    css/LengthFunctions.h \
     css/MediaFeatureNames.h \
     css/MediaList.h \

trunk/Source/WebCore/WebCore.gypi

@@ -90 +90 @@
             'css/CSSValueList.h',
             'css/CSSWrapShapes.h',
+            'css/LengthFunctions.h',
             'css/Pair.h',
             'css/WebKitCSSFilterValue.h',

trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

@@ -36475 +36475 @@
                         </File>
                         <File
+                                RelativePath="..\css\LengthFunctions.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\css\MediaAllInOne.cpp"
                                 >

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -5959 +5959 @@
                 E4D687770ED7AE3D006EA978 /* PurgeableBufferMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4D687760ED7AE3D006EA978 /* PurgeableBufferMac.cpp */; };
                 E4D687790ED7AE4F006EA978 /* PurgeableBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = E4D687780ED7AE4F006EA978 /* PurgeableBuffer.h */; };
+                E5BA7D63151437CA00FE1E3F /* LengthFunctions.h in Headers */ = {isa = PBXBuildFile; fileRef = E5BA7D62151437CA00FE1E3F /* LengthFunctions.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 ED2BA83C09A24B91006C0AC4 /* DocumentMarker.h in Headers */ = {isa = PBXBuildFile; fileRef = ED2BA83B09A24B91006C0AC4 /* DocumentMarker.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 ED501DC60B249F2900AE18D9 /* EditorMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = ED501DC50B249F2900AE18D9 /* EditorMac.mm */; };
@@ -13072 +13073 @@
                 E4D687760ED7AE3D006EA978 /* PurgeableBufferMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PurgeableBufferMac.cpp; sourceTree = "<group>"; };
                 E4D687780ED7AE4F006EA978 /* PurgeableBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PurgeableBuffer.h; sourceTree = "<group>"; };
+                E5BA7D62151437CA00FE1E3F /* LengthFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LengthFunctions.h; sourceTree = "<group>"; };
                 ED2BA83B09A24B91006C0AC4 /* DocumentMarker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DocumentMarker.h; sourceTree = "<group>"; };
                 ED501DC50B249F2900AE18D9 /* EditorMac.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; name = EditorMac.mm; path = mac/EditorMac.mm; sourceTree = "<group>"; };
@@ -20472 +20474 @@
                                 CDBD93BA1333BD4B002570E3 /* fullscreenQuickTime.css */,
                                 93CA4C9909DF93FA00DF8677 /* html.css */,
+                                E5BA7D62151437CA00FE1E3F /* LengthFunctions.h */,
                                 93CA4C9A09DF93FA00DF8677 /* make-css-file-arrays.pl */,
                                 93CA4C9B09DF93FA00DF8677 /* makeprop.pl */,
@@ -23474 +23477 @@
                                 BCE65BEB0EACDF16007E4533 /* Length.h in Headers */,
                                 BCFF64910EAD15C200C1D6F7 /* LengthBox.h in Headers */,
+                                E5BA7D63151437CA00FE1E3F /* LengthFunctions.h in Headers */,
                                 BCFF64920EAD15C200C1D6F7 /* LengthSize.h in Headers */,
                                 8CADF2A9135C7B36009EF43F /* LevelDBComparator.h in Headers */,

trunk/Source/WebCore/accessibility/gtk/WebKitAccessibleInterfaceText.cpp

@@ -241 +241 @@
 
     if (!style->textIndent().isUndefined()) {
-        int indentation = style->textIndent().calcValue(object->size().width());
+        int indentation = valueForLength(style->textIndent(), object->size().width());
         buffer.set(g_strdup_printf("%i", indentation));
         result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INDENT), buffer.get());

trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1775 +1775 @@
                 // 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 = marginRight.calcMinValue(toRenderBox(renderer)->containingBlockLogicalWidthForContent());
+                value = miminumValueForLength(marginRight, toRenderBox(renderer)->containingBlockLogicalWidthForContent());
             else
                 value = toRenderBox(renderer)->marginRight();
@@ -2187 +2187 @@
             if (renderer) {
                 LayoutRect box = sizingBox(renderer);
-                list->append(zoomAdjustedPixelValue(style->perspectiveOriginX().calcMinValue(box.width()), style.get(), cssValuePool));
-                list->append(zoomAdjustedPixelValue(style->perspectiveOriginY().calcMinValue(box.height()), style.get(), cssValuePool));
+                list->append(zoomAdjustedPixelValue(miminumValueForLength(style->perspectiveOriginX(), box.width()), style.get(), cssValuePool));
+                list->append(zoomAdjustedPixelValue(miminumValueForLength(style->perspectiveOriginY(), box.height()), style.get(), cssValuePool));
             }
             else {
@@ -2233 +2233 @@
             if (renderer) {
                 IntRect box = sizingBox(renderer);
-                list->append(zoomAdjustedPixelValue(style->transformOriginX().calcMinValue(box.width()), style.get(), cssValuePool));
-                list->append(zoomAdjustedPixelValue(style->transformOriginY().calcMinValue(box.height()), style.get(), cssValuePool));
+                list->append(zoomAdjustedPixelValue(miminumValueForLength(style->transformOriginX(), box.width()), style.get(), cssValuePool));
+                list->append(zoomAdjustedPixelValue(miminumValueForLength(style->transformOriginY(), box.height()), style.get(), cssValuePool));
                 if (style->transformOriginZ() != 0)
                     list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get(), cssValuePool));

trunk/Source/WebCore/dom/Document.cpp

@@ -1803 +1803 @@
         ASSERT(size.width().isFixed());
         ASSERT(size.height().isFixed());
-        width = size.width().calcValue(0);
-        height = size.height().calcValue(0);
+        width = valueForLength(size.width(), 0);
+        height = valueForLength(size.height(), 0);
         break;
     }
@@ -1814 +1814 @@
     // 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 : style->marginTop().calcValue(width);
-    marginRight = style->marginRight().isAuto() ? marginRight : style->marginRight().calcValue(width);
-    marginBottom = style->marginBottom().isAuto() ? marginBottom : style->marginBottom().calcValue(width);
-    marginLeft = style->marginLeft().isAuto() ? marginLeft : style->marginLeft().calcValue(width);
+    marginTop = style->marginTop().isAuto() ? marginTop : valueForLength(style->marginTop(), width);
+    marginRight = style->marginRight().isAuto() ? marginRight : valueForLength(style->marginRight(), width);
+    marginBottom = style->marginBottom().isAuto() ? marginBottom : valueForLength(style->marginBottom(), width);
+    marginLeft = style->marginLeft().isAuto() ? marginLeft : valueForLength(style->marginLeft(), width);
 }
 

trunk/Source/WebCore/html/HTMLAreaElement.cpp

@@ -148 +148 @@
             if (m_coordsLen >= 6) {
                 int numPoints = m_coordsLen / 2;
-                path.moveTo(FloatPoint(m_coords[0].calcMinValue(width), m_coords[1].calcMinValue(height)));
+                path.moveTo(FloatPoint(miminumValueForLength(m_coords[0], width), miminumValueForLength(m_coords[1], height)));
                 for (int i = 1; i < numPoints; ++i)
-                    path.addLineTo(FloatPoint(m_coords[i * 2].calcMinValue(width), m_coords[i * 2 + 1].calcMinValue(height)));
+                    path.addLineTo(FloatPoint(miminumValueForLength(m_coords[i * 2], width), miminumValueForLength(m_coords[i * 2 + 1], height)));
                 path.closeSubpath();
             }
@@ -157 +157 @@
             if (m_coordsLen >= 3) {
                 Length radius = m_coords[2];
-                int r = min(radius.calcMinValue(width), radius.calcMinValue(height));
-                path.addEllipse(FloatRect(m_coords[0].calcMinValue(width) - r, m_coords[1].calcMinValue(height) - r, 2 * r, 2 * r));
+                int r = min(miminumValueForLength(radius, width), miminumValueForLength(radius, height));
+                path.addEllipse(FloatRect(miminumValueForLength(m_coords[0], width) - r, miminumValueForLength(m_coords[1], height) - r, 2 * r, 2 * r));
             }
             break;
         case Rect:
             if (m_coordsLen >= 4) {
-                int x0 = m_coords[0].calcMinValue(width);
-                int y0 = m_coords[1].calcMinValue(height);
-                int x1 = m_coords[2].calcMinValue(width);
-                int y1 = m_coords[3].calcMinValue(height);
+                int x0 = miminumValueForLength(m_coords[0], width);
+                int y0 = miminumValueForLength(m_coords[1], height);
+                int x1 = miminumValueForLength(m_coords[2], width);
+                int y1 = miminumValueForLength(m_coords[3], height);
                 path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
             }

trunk/Source/WebCore/platform/CalculationValue.h

@@ -33 +33 @@
 
 #include "Length.h"
+#include "LengthFunctions.h"
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
@@ -102 +103 @@
     virtual float evaluate(float maxValue) const
     {
-        return m_length.calcFloatValue(maxValue);
+        return floatValueForLength(m_length, maxValue);
     }
     

trunk/Source/WebCore/platform/Length.h

@@ -160 +160 @@
     }
 
-    int calcValue(int maxValue, bool roundPercentages = false) const
-    {
-        switch (type()) {
-            case Fixed:
-            case Percent:
-            case Calculated:
-                return calcMinValue(maxValue, roundPercentages);
-            case Auto:
-                return maxValue;
-            case Relative:
-            case Intrinsic:
-            case MinIntrinsic:
-            case Undefined:
-                ASSERT_NOT_REACHED();
-                return 0;
-        }
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-
-    int calcMinValue(int maxValue, bool roundPercentages = false) const
-    {
-        switch (type()) {
-            case Fixed:
-                return value();
-            case Percent:
-                if (roundPercentages)
-                    return static_cast<int>(round(maxValue * percent() / 100.0f));
-                // 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<int>(static_cast<float>(maxValue * percent() / 100.0f));
-            case Calculated:
-                return nonNanCalculatedValue(maxValue);
-            case Auto:
-                return 0;
-            case Relative:
-            case Intrinsic:
-            case MinIntrinsic:
-            case Undefined:
-                ASSERT_NOT_REACHED();
-                return 0;
-        }
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-
-    // FIXME: when subpixel layout is supported this copy of calcFloatValue() can be removed. See bug 71143.
-    float calcFloatValue(int maxValue) const
-    {
-        switch (type()) {
-            case Fixed:
-                return getFloatValue();
-            case Percent:
-                return static_cast<float>(maxValue * percent() / 100.0f);
-            case Auto:
-                return static_cast<float>(maxValue);
-            case Calculated:
-                return nonNanCalculatedValue(maxValue);                
-            case Relative:
-            case Intrinsic:
-            case MinIntrinsic:
-            case Undefined:
-                ASSERT_NOT_REACHED();
-                return 0;
-        }
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-
-    float calcFloatValue(float maxValue) const
-    {
-        switch (type()) {
-        case Fixed:
-            return getFloatValue();
-        case Percent:
-            return static_cast<float>(maxValue * percent() / 100.0f);
-        case Auto:
-            return static_cast<float>(maxValue);
-        case Calculated:
-            return nonNanCalculatedValue(maxValue);
-        case Relative:
-        case Intrinsic:
-        case MinIntrinsic:
-        case Undefined:
-            ASSERT_NOT_REACHED();
-            return 0;
-        }
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-
     bool isUndefined() const { return type() == Undefined; }
 
@@ -313 +223 @@
     }
 
+    float getFloatValue() const
+    {
+        ASSERT(!isUndefined());
+        return m_isFloat ? m_floatValue : m_intValue;
+    }
+    float nonNanCalculatedValue(int maxValue) const;
+
 private:
     int getIntValue() const
@@ -319 +236 @@
         return m_isFloat ? static_cast<int>(m_floatValue) : m_intValue;
     }
-
-    float getFloatValue() const
-    {
-        ASSERT(!isUndefined());
-        return m_isFloat ? m_floatValue : m_intValue;
-    }
-
     void initFromLength(const Length &length) 
     {
@@ -340 +250 @@
             incrementCalculatedRef();
     }
-    
-    float nonNanCalculatedValue(int maxValue) const;
+
     int calculationHandle() const
     {

trunk/Source/WebCore/platform/graphics/ca/mac/PlatformCAAnimationMac.mm

@@ -31 +31 @@
 
 #import "FloatConversion.h"
+#import "LengthFunctions.h"
 #import "PlatformString.h"
 #import "TimingFunction.h"
@@ -503 +504 @@
         if (!operation->isDefault()) {
             const BlurFilterOperation* op = static_cast<const BlurFilterOperation*>(operation);
-            amount = op->stdDeviation().calcFloatValue(0);
+            amount = floatValueForLength(op->stdDeviation(), 0);
         }
         

trunk/Source/WebCore/platform/graphics/ca/mac/PlatformCALayerMac.mm

@@ -35 +35 @@
 #import "GraphicsContext.h"
 #import "GraphicsLayerCA.h"
+#import "LengthFunctions.h"
 #import "WebLayer.h"
 #import "WebTiledLayer.h"
@@ -824 +825 @@
             CIFilter* caFilter = [CIFilter filterWithName:@"CIGaussianBlur"];
             [caFilter setDefaults];
-            [caFilter setValue:[NSNumber numberWithFloat:op->stdDeviation().calcFloatValue(0)] forKey:@"inputRadius"];
+            [caFilter setValue:[NSNumber numberWithFloat:floatValueForLength(op->stdDeviation(), 0)] forKey:@"inputRadius"];
             [caFilter setName:filterName];
             [array.get() addObject:caFilter];

trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp

@@ -31 +31 @@
 
 #include "GraphicsContext3D.h"
+#include "LengthFunctions.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ -270 +271 @@
         case FilterOperation::BLUR: {
             const BlurFilterOperation* op = static_cast<const BlurFilterOperation*>(filterOperation);
-            float stdX = op->stdDeviation().calcFloatValue(0);
-            float stdY = op->stdDeviation().calcFloatValue(1);
+            float stdX = floatValueForLength(op->stdDeviation(), 0);
+            float stdY = floatValueForLength(op->stdDeviation(), 1);
             SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdX, stdY));
             SkPaint paint;

trunk/Source/WebCore/platform/graphics/filters/FilterOperations.cpp

@@ -29 +29 @@
 #include "FEGaussianBlur.h"
 #include "IntSize.h"
+#include "LengthFunctions.h"
 
 #if ENABLE(CSS_FILTERS)
@@ -108 +109 @@
         case FilterOperation::BLUR: {
             BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);
-            float stdDeviation = blurOperation->stdDeviation().calcFloatValue(0);
+            float stdDeviation = floatValueForLength(blurOperation->stdDeviation(), 0);
             IntSize outset = outsetSizeForBlur(stdDeviation);
             top += outset.height();

trunk/Source/WebCore/platform/graphics/transforms/PerspectiveTransformOperation.cpp

@@ -40 +40 @@
     
     if (blendToIdentity) {
-        double p = m_p.calcFloatValue(1);
+        double p = floatValueForLength(m_p, 1);
         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));
@@ -51 +51 @@
     TransformationMatrix fromT;
     TransformationMatrix toT;
-    fromT.applyPerspective(fromP.calcFloatValue(1));
-    toT.applyPerspective(toP.calcFloatValue(1));
+    fromT.applyPerspective(floatValueForLength(fromP, 1));
+    toT.applyPerspective(floatValueForLength(toP, 1));
     toT.blend(fromT, progress);
     TransformationMatrix::DecomposedType decomp;

trunk/Source/WebCore/platform/graphics/transforms/PerspectiveTransformOperation.h

@@ -28 +28 @@
 
 #include "Length.h"
+#include "LengthFunctions.h"
 #include "TransformOperation.h"
 
@@ -42 +43 @@
     
 private:
-    virtual bool isIdentity() const { return m_p.calcFloatValue(1) == 0; }
+    virtual bool isIdentity() const { return !floatValueForLength(m_p, 1); }
     virtual OperationType getOperationType() const { return PERSPECTIVE; }
     virtual bool isSameType(const TransformOperation& o) const { return o.getOperationType() == PERSPECTIVE; }
@@ -56 +57 @@
     virtual bool apply(TransformationMatrix& transform, const FloatSize&) const
     {
-        transform.applyPerspective(m_p.calcFloatValue(1));
+        transform.applyPerspective(floatValueForLength(m_p, 1));
         return false;
     }

trunk/Source/WebCore/platform/graphics/transforms/TranslateTransformOperation.h

@@ -27 +27 @@
 
 #include "Length.h"
+#include "LengthFunctions.h"
 #include "TransformOperation.h"
 
@@ -43 +44 @@
     }
 
-    double x(const FloatSize& borderBoxSize) const { return m_x.calcFloatValue(borderBoxSize.width()); }
-    double y(const FloatSize& borderBoxSize) const { return m_y.calcFloatValue(borderBoxSize.height()); }
-    double z(const FloatSize&) const { return m_z.calcFloatValue(1); }
+    double x(const FloatSize& borderBoxSize) const { return floatValueForLength(m_x, borderBoxSize.width()); }
+    double y(const FloatSize& borderBoxSize) const { return floatValueForLength(m_y, borderBoxSize.height()); }
+    double z(const FloatSize&) const { return floatValueForLength(m_z, 1); }
 
     Length x() const { return m_x; }
@@ -52 +53 @@
 
 private:
-    virtual bool isIdentity() const { return m_x.calcFloatValue(1) == 0 && m_y.calcFloatValue(1) == 0 && m_z.calcFloatValue(1) == 0; }
+    virtual bool isIdentity() const { return !floatValueForLength(m_x, 1) && !floatValueForLength(m_y, 1) && !floatValueForLength(m_z, 1); }
 
     virtual OperationType getOperationType() const { return m_type; }

trunk/Source/WebCore/platform/win/PopupMenuWin.cpp

@@ -34 +34 @@
 #include "HWndDC.h"
 #include "HostWindow.h"
+#include "LengthFunctions.h"
 #include "Page.h"
 #include "PlatformMouseEvent.h"
@@ -655 +656 @@
             int textX = max(0, client()->clientPaddingLeft() - client()->clientInsetLeft());
             if (RenderTheme::defaultTheme()->popupOptionSupportsTextIndent() && itemStyle.textDirection() == LTR)
-                textX += itemStyle.textIndent().calcMinValue(itemRect.width());
+                textX += miminumValueForLength(itemStyle.textIndent(), itemRect.width());
             int textY = itemRect.y() + itemFont.fontMetrics().ascent() + (itemRect.height() - itemFont.fontMetrics().height()) / 2;
             context.drawBidiText(itemFont, textRun, IntPoint(textX, textY));

trunk/Source/WebCore/rendering/AutoTableLayout.cpp

@@ -552 +552 @@
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.isPercent()) {
-                int cellLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, logicalWidth.calcMinValue(tableLogicalWidth));
+                int cellLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, miminumValueForLength(logicalWidth, tableLogicalWidth));
                 available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
                 m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;

trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp

@@ -238 +238 @@
         case FilterOperation::BLUR: {
             BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);
-            float stdDeviation = blurOperation->stdDeviation().calcFloatValue(0);
+            float stdDeviation = floatValueForLength(blurOperation->stdDeviation(), 0);
             effect = FEGaussianBlur::create(this, stdDeviation, stdDeviation);
             break;

trunk/Source/WebCore/rendering/FixedTableLayout.cpp

@@ -245 +245 @@
             totalFixedWidth += calcWidth[i];
         } else if (m_width[i].isPercent()) {
-            calcWidth[i] = m_width[i].calcValue(tableLogicalWidth);
+            calcWidth[i] = valueForLength(m_width[i], tableLogicalWidth);
             totalPercentWidth += calcWidth[i];
             totalPercent += m_width[i].percent();

trunk/Source/WebCore/rendering/RenderBlock.cpp

@@ -3902 +3902 @@
     if (style()->textIndent().isPercent())
         cw = containingBlock()->availableLogicalWidth();
-    return style()->textIndent().calcMinValue(cw);
+    return miminumValueForLength(style()->textIndent(), cw);
 }
 
@@ -5542 +5542 @@
                 if (!addedTextIndent) {
                     addedTextIndent = true;
-                    ti = styleToUse->textIndent().calcMinValue(cw);
+                    ti = miminumValueForLength(styleToUse->textIndent(), cw);
                     childMin += ti;
                     childMax += ti;
@@ -5613 +5613 @@
                 if (!addedTextIndent) {
                     addedTextIndent = true;
-                    ti = styleToUse->textIndent().calcMinValue(cw);
+                    ti = miminumValueForLength(styleToUse->textIndent(), cw);
                     childMin+=ti; beginMin += ti;
                     childMax+=ti; beginMax += ti;

trunk/Source/WebCore/rendering/RenderBox.cpp

@@ -624 +624 @@
         return 0;
     if (style()->boxReflect()->direction() == ReflectionLeft || style()->boxReflect()->direction() == ReflectionRight)
-        return style()->boxReflect()->offset().calcValue(borderBoxRect().width());
-    return style()->boxReflect()->offset().calcValue(borderBoxRect().height());
+        return valueForLength(style()->boxReflect()->offset(), borderBoxRect().width());
+    return valueForLength(style()->boxReflect()->offset(), borderBoxRect().height());
 }
 
@@ -1295 +1295 @@
 
     if (!style()->clipLeft().isAuto()) {
-        LayoutUnit c = style()->clipLeft().calcValue(borderBoxRect.width());
+        LayoutUnit c = valueForLength(style()->clipLeft(), borderBoxRect.width());
         clipRect.move(c, 0);
         clipRect.contract(c, 0);
@@ -1304 +1304 @@
 
     if (!style()->clipRight().isAuto())
-        clipRect.contract(width() - style()->clipRight().calcValue(width()), 0);
+        clipRect.contract(width() - valueForLength(style()->clipRight(), width()), 0);
 
     if (!style()->clipTop().isAuto()) {
-        LayoutUnit c = style()->clipTop().calcValue(borderBoxRect.height());
+        LayoutUnit c = valueForLength(style()->clipTop(), borderBoxRect.height());
         clipRect.move(0, c);
         clipRect.contract(0, c);
@@ -1313 +1313 @@
 
     if (!style()->clipBottom().isAuto())
-        clipRect.contract(0, height() - style()->clipBottom().calcValue(height()));
+        clipRect.contract(0, height() - valueForLength(style()->clipBottom(), height()));
 
     return clipRect;
@@ -1780 +1780 @@
     if (isInline() && !isInlineBlockOrInlineTable()) {
         // just calculate margins
-        setMarginStart(styleToUse->marginStart().calcMinValue(containerLogicalWidth));
-        setMarginEnd(styleToUse->marginEnd().calcMinValue(containerLogicalWidth));
+        setMarginStart(miminumValueForLength(styleToUse->marginStart(), containerLogicalWidth));
+        setMarginEnd(miminumValueForLength(styleToUse->marginEnd(), containerLogicalWidth));
         if (treatAsReplaced)
-            setLogicalWidth(max<LayoutUnit>(logicalWidthLength.calcFloatValue(0) + borderAndPaddingLogicalWidth(), minPreferredLogicalWidth()));
+            setLogicalWidth(max<LayoutUnit>(floatValueForLength(logicalWidthLength, 0) + borderAndPaddingLogicalWidth(), minPreferredLogicalWidth()));
         return;
     }
@@ -1819 +1819 @@
     // Margin calculations.
     if (logicalWidthLength.isAuto() || hasPerpendicularContainingBlock) {
-        setMarginStart(styleToUse->marginStart().calcMinValue(containerLogicalWidth));
-        setMarginEnd(styleToUse->marginEnd().calcMinValue(containerLogicalWidth));
+        setMarginStart(miminumValueForLength(styleToUse->marginStart(), containerLogicalWidth));
+        setMarginEnd(miminumValueForLength(styleToUse->marginEnd(), containerLogicalWidth));
     } else
         computeInlineDirectionMargins(cb, containerLogicalWidth, logicalWidth());
@@ -1843 +1843 @@
 
     if (logicalWidth.isIntrinsicOrAuto()) {
-        LayoutUnit marginStart = styleToUse->marginStart().calcMinValue(availableLogicalWidth);
-        LayoutUnit marginEnd = styleToUse->marginEnd().calcMinValue(availableLogicalWidth);
+        LayoutUnit marginStart = miminumValueForLength(styleToUse->marginStart(), availableLogicalWidth);
+        LayoutUnit marginEnd = miminumValueForLength(styleToUse->marginEnd(), availableLogicalWidth);
         logicalWidthResult = availableLogicalWidth - marginStart - marginEnd;
 
@@ -1855 +1855 @@
         }
     } else // FIXME: If the containing block flow is perpendicular to our direction we need to use the available logical height instead.
-        logicalWidthResult = computeBorderBoxLogicalWidth(logicalWidth.calcValue(availableLogicalWidth)); 
+        logicalWidthResult = computeBorderBoxLogicalWidth(valueForLength(logicalWidth, availableLogicalWidth)); 
 
     return logicalWidthResult;
@@ -1926 +1926 @@
     if (isFloating() || isInline()) {
         // Inline blocks/tables and floats don't have their margins increased.
-        containingBlock->setMarginStartForChild(this, marginStartLength.calcMinValue(containerWidth));
-        containingBlock->setMarginEndForChild(this, marginEndLength.calcMinValue(containerWidth));
+        containingBlock->setMarginStartForChild(this, miminumValueForLength(marginStartLength, containerWidth));
+        containingBlock->setMarginEndForChild(this, miminumValueForLength(marginEndLength, containerWidth));
         return;
     }
@@ -1941 +1941 @@
     // Case Two: The object is being pushed to the start of the containing block's available logical width.
     if (marginEndLength.isAuto() && childWidth < containerWidth) {
-        containingBlock->setMarginStartForChild(this, marginStartLength.calcValue(containerWidth));
+        containingBlock->setMarginStartForChild(this, valueForLength(marginStartLength, containerWidth));
         containingBlock->setMarginEndForChild(this, containerWidth - childWidth - containingBlock->marginStartForChild(this));
         return;
@@ -1950 +1950 @@
         || (containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_RIGHT));
     if ((marginStartLength.isAuto() && childWidth < containerWidth) || pushToEndFromTextAlign) {
-        containingBlock->setMarginEndForChild(this, marginEndLength.calcValue(containerWidth));
+        containingBlock->setMarginEndForChild(this, valueForLength(marginEndLength, containerWidth));
         containingBlock->setMarginStartForChild(this, containerWidth - childWidth - containingBlock->marginEndForChild(this));
         return;
@@ -1957 +1957 @@
     // 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.
-    containingBlock->setMarginStartForChild(this, marginStartLength.calcMinValue(containerWidth));
-    containingBlock->setMarginEndForChild(this, marginEndLength.calcMinValue(containerWidth));
+    containingBlock->setMarginStartForChild(this, miminumValueForLength(marginStartLength, containerWidth));
+    containingBlock->setMarginEndForChild(this, miminumValueForLength(marginEndLength, containerWidth));
 }
 
@@ -2246 +2246 @@
 
     if (result != -1) {
-        result = height.calcValue(result);
+        result = valueForLength(height, result);
         if (includeBorderPadding) {
             // It is necessary to use the border-box to match WinIE's broken
@@ -2281 +2281 @@
             const LayoutUnit cw = isPositioned() ? containingBlockLogicalWidthForPositioned(toRenderBoxModelObject(container())) : containingBlockLogicalWidthForContent();
             if (cw > 0)
-                return computeContentBoxLogicalWidth(logicalWidth.calcMinValue(cw));
+                return computeContentBoxLogicalWidth(miminumValueForLength(logicalWidth, cw));
         }
         // fall through
@@ -2323 +2323 @@
                 LayoutUnit newHeight = block->computeContentBoxLogicalHeight(block->contentHeight());
                 block->setHeight(oldHeight);
-                return computeContentBoxLogicalHeight(logicalHeight.calcValue(newHeight));
+                return computeContentBoxLogicalHeight(valueForLength(logicalHeight, newHeight));
             }
             
@@ -2344 +2344 @@
                         // <http://bugs.webkit.org/show_bug.cgi?id=15359>
                         availableHeight = max(availableHeight, intrinsicLogicalHeight());
-                        return logicalHeight.calcValue(availableHeight - borderAndPaddingLogicalHeight());
+                        return valueForLength(logicalHeight, availableHeight - borderAndPaddingLogicalHeight());
                     }
                     cb = cb->containingBlock();
@@ -2350 +2350 @@
                 }
             }
-            return computeContentBoxLogicalHeight(logicalHeight.calcValue(availableHeight));
+            return computeContentBoxLogicalHeight(valueForLength(logicalHeight, availableHeight));
         }
         default:
@@ -2385 +2385 @@
         else
             availableHeight = containingBlock()->availableLogicalHeight();
-        return computeContentBoxLogicalHeight(h.calcValue(availableHeight));
+        return computeContentBoxLogicalHeight(valueForLength(h, availableHeight));
     }
 
@@ -2417 +2417 @@
 
     RenderStyle* containingBlockStyle = containingBlock->style();
-    containingBlock->setMarginBeforeForChild(this, style()->marginBeforeUsing(containingBlockStyle).calcMinValue(cw));
-    containingBlock->setMarginAfterForChild(this, style()->marginAfterUsing(containingBlockStyle).calcMinValue(cw));
+    containingBlock->setMarginBeforeForChild(this, miminumValueForLength(style()->marginBeforeUsing(containingBlockStyle), cw));
+    containingBlock->setMarginAfterForChild(this, miminumValueForLength(style()->marginAfterUsing(containingBlockStyle), cw));
 }
 
@@ -2758 +2758 @@
         // case because the value is not used for any further calculations.
 
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-        logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));
-
-        const LayoutUnit availableSpace = containerLogicalWidth - (logicalLeftValue + logicalWidthValue + logicalRight.calcValue(containerLogicalWidth) + bordersPlusPadding);
+        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+        logicalWidthValue = computeContentBoxLogicalWidth(valueForLength(logicalWidth, containerLogicalWidth));
+
+        const LayoutUnit availableSpace = containerLogicalWidth - (logicalLeftValue + logicalWidthValue + valueForLength(logicalRight, containerLogicalWidth) + bordersPlusPadding);
 
         // Margins are now the only unknown
@@ -2782 +2782 @@
         } else if (marginLogicalLeft.isAuto()) {
             // Solve for left margin
-            marginLogicalRightValue = marginLogicalRight.calcValue(containerLogicalWidth);
+            marginLogicalRightValue = valueForLength(marginLogicalRight, containerLogicalWidth);
             marginLogicalLeftValue = availableSpace - marginLogicalRightValue;
         } else if (marginLogicalRight.isAuto()) {
             // Solve for right margin
-            marginLogicalLeftValue = marginLogicalLeft.calcValue(containerLogicalWidth);
+            marginLogicalLeftValue = valueForLength(marginLogicalLeft, containerLogicalWidth);
             marginLogicalRightValue = availableSpace - marginLogicalLeftValue;
         } else {
             // Over-constrained, solve for left if direction is RTL
-            marginLogicalLeftValue = marginLogicalLeft.calcValue(containerLogicalWidth);
-            marginLogicalRightValue = marginLogicalRight.calcValue(containerLogicalWidth);
+            marginLogicalLeftValue = valueForLength(marginLogicalLeft, containerLogicalWidth);
+            marginLogicalRightValue = valueForLength(marginLogicalRight, containerLogicalWidth);
 
             // Use the containing block's direction rather than the parent block's
@@ -2841 +2841 @@
 
         // Calculate margins, 'auto' margins are ignored.
-        marginLogicalLeftValue = marginLogicalLeft.calcMinValue(containerLogicalWidth);
-        marginLogicalRightValue = marginLogicalRight.calcMinValue(containerLogicalWidth);
+        marginLogicalLeftValue = miminumValueForLength(marginLogicalLeft, containerLogicalWidth);
+        marginLogicalRightValue = miminumValueForLength(marginLogicalRight, containerLogicalWidth);
 
         const LayoutUnit availableSpace = containerLogicalWidth - (marginLogicalLeftValue + marginLogicalRightValue + bordersPlusPadding);
@@ -2850 +2850 @@
         if (logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {
             // RULE 1: (use shrink-to-fit for width, and solve of left)
-            LayoutUnit logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
+            LayoutUnit logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
             // FIXME: would it be better to have shrink-to-fit in one step?
@@ -2860 +2860 @@
         } else if (!logicalLeftIsAuto && logicalWidthIsAuto && logicalRightIsAuto) {
             // RULE 3: (use shrink-to-fit for width, and no need solve of right)
-            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
+            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
 
             // FIXME: would it be better to have shrink-to-fit in one step?
@@ -2869 +2869 @@
         } else if (logicalLeftIsAuto && !logicalWidthIsAuto && !logicalRightIsAuto) {
             // RULE 4: (solve for left)
-            logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));
-            logicalLeftValue = availableSpace - (logicalWidthValue + logicalRight.calcValue(containerLogicalWidth));
+            logicalWidthValue = computeContentBoxLogicalWidth(valueForLength(logicalWidth, containerLogicalWidth));
+            logicalLeftValue = availableSpace - (logicalWidthValue + valueForLength(logicalRight, containerLogicalWidth));
         } else if (!logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {
             // RULE 5: (solve for width)
-            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-            logicalWidthValue = availableSpace - (logicalLeftValue + logicalRight.calcValue(containerLogicalWidth));
+            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+            logicalWidthValue = availableSpace - (logicalLeftValue + valueForLength(logicalRight, containerLogicalWidth));
         } else if (!logicalLeftIsAuto && !logicalWidthIsAuto && logicalRightIsAuto) {
             // RULE 6: (no need solve for right)
-            logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-            logicalWidthValue = computeContentBoxLogicalWidth(logicalWidth.calcValue(containerLogicalWidth));
+            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+            logicalWidthValue = computeContentBoxLogicalWidth(valueForLength(logicalWidth, containerLogicalWidth));
         }
     }
@@ -3093 +3093 @@
         // case because the value is not used for any further calculations.
 
-        logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
-
-        const LayoutUnit availableSpace = containerLogicalHeight - (logicalTopValue + logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight) + bordersPlusPadding);
+        logicalHeightValue = computeContentBoxLogicalHeight(valueForLength(logicalHeightLength, containerLogicalHeight));
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
+
+        const LayoutUnit availableSpace = containerLogicalHeight - (logicalTopValue + logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight) + bordersPlusPadding);
 
         // Margins are now the only unknown
@@ -3106 +3106 @@
         } else if (marginBefore.isAuto()) {
             // Solve for top margin
-            marginAfterValue = marginAfter.calcValue(containerLogicalHeight);
+            marginAfterValue = valueForLength(marginAfter, containerLogicalHeight);
             marginBeforeValue = availableSpace - marginAfterValue;
         } else if (marginAfter.isAuto()) {
             // Solve for bottom margin
-            marginBeforeValue = marginBefore.calcValue(containerLogicalHeight);
+            marginBeforeValue = valueForLength(marginBefore, containerLogicalHeight);
             marginAfterValue = availableSpace - marginBeforeValue;
         } else {
             // Over-constrained, (no need solve for bottom)
-            marginBeforeValue = marginBefore.calcValue(containerLogicalHeight);
-            marginAfterValue = marginAfter.calcValue(containerLogicalHeight);
+            marginBeforeValue = valueForLength(marginBefore, containerLogicalHeight);
+            marginAfterValue = valueForLength(marginAfter, containerLogicalHeight);
         }
     } else {
@@ -3144 +3144 @@
 
         // Calculate margins, 'auto' margins are ignored.
-        marginBeforeValue = marginBefore.calcMinValue(containerLogicalHeight);
-        marginAfterValue = marginAfter.calcMinValue(containerLogicalHeight);
+        marginBeforeValue = miminumValueForLength(marginBefore, containerLogicalHeight);
+        marginAfterValue = miminumValueForLength(marginAfter, containerLogicalHeight);
 
         const LayoutUnit availableSpace = containerLogicalHeight - (marginBeforeValue + marginAfterValue + bordersPlusPadding);
@@ -3153 +3153 @@
             // RULE 1: (height is content based, solve of top)
             logicalHeightValue = contentLogicalHeight;
-            logicalTopValue = availableSpace - (logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight));
+            logicalTopValue = availableSpace - (logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight));
         } else if (!logicalTopIsAuto && logicalHeightIsAuto && logicalBottomIsAuto) {
             // RULE 3: (height is content based, no need solve of bottom)
-            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
+            logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
             logicalHeightValue = contentLogicalHeight;
         } else if (logicalTopIsAuto && !logicalHeightIsAuto && !logicalBottomIsAuto) {
             // RULE 4: (solve of top)
-            logicalHeightValue = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));
-            logicalTopValue = availableSpace - (logicalHeightValue + logicalBottom.calcValue(containerLogicalHeight));
+            logicalHeightValue = computeContentBoxLogicalHeight(valueForLength(logicalHeightLength, containerLogicalHeight));
+            logicalTopValue = availableSpace - (logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight));
         } else if (!logicalTopIsAuto && logicalHeightIsAuto && !logicalBottomIsAuto) {
             // RULE 5: (solve of height)
-            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
-            logicalHeightValue = max<LayoutUnit>(0, availableSpace - (logicalTopValue + logicalBottom.calcValue(containerLogicalHeight)));
+            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 = computeContentBoxLogicalHeight(logicalHeightLength.calcValue(containerLogicalHeight));
-            logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
+            logicalHeightValue = computeContentBoxLogicalHeight(valueForLength(logicalHeightLength, containerLogicalHeight));
+            logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
         }
     }
@@ -3250 +3250 @@
         ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));
 
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-        logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
+        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
         LayoutUnit difference = availableSpace - (logicalLeftValue + logicalRightValue);
@@ -3274 +3274 @@
     \*-----------------------------------------------------------------------*/
     } else if (logicalLeft.isAuto()) {
-        marginLogicalLeftAlias = marginLogicalLeft.calcValue(containerLogicalWidth);
-        marginLogicalRightAlias = marginLogicalRight.calcValue(containerLogicalWidth);
-        logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
+        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerLogicalWidth);
+        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerLogicalWidth);
+        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
         // Solve for 'left'
         logicalLeftValue = availableSpace - (logicalRightValue + marginLogicalLeftAlias + marginLogicalRightAlias);
     } else if (logicalRight.isAuto()) {
-        marginLogicalLeftAlias = marginLogicalLeft.calcValue(containerLogicalWidth);
-        marginLogicalRightAlias = marginLogicalRight.calcValue(containerLogicalWidth);
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
+        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerLogicalWidth);
+        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerLogicalWidth);
+        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
 
         // Solve for 'right'
         logicalRightValue = availableSpace - (logicalLeftValue + marginLogicalLeftAlias + marginLogicalRightAlias);
     } else if (marginLogicalLeft.isAuto()) {
-        marginLogicalRightAlias = marginLogicalRight.calcValue(containerLogicalWidth);
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-        logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
+        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerLogicalWidth);
+        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
         // Solve for 'margin-left'
         marginLogicalLeftAlias = availableSpace - (logicalLeftValue + logicalRightValue + marginLogicalRightAlias);
     } else if (marginLogicalRight.isAuto()) {
-        marginLogicalLeftAlias = marginLogicalLeft.calcValue(containerLogicalWidth);
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
-        logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
+        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerLogicalWidth);
+        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
+        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
 
         // Solve for 'margin-right'
@@ -3303 +3303 @@
     } else {
         // Nothing is 'auto', just calculate the values.
-        marginLogicalLeftAlias = marginLogicalLeft.calcValue(containerLogicalWidth);
-        marginLogicalRightAlias = marginLogicalRight.calcValue(containerLogicalWidth);
-        logicalRightValue = logicalRight.calcValue(containerLogicalWidth);
-        logicalLeftValue = logicalLeft.calcValue(containerLogicalWidth);
+        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerLogicalWidth);
+        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerLogicalWidth);
+        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) {
@@ -3412 +3412 @@
         ASSERT(!(logicalTop.isAuto() || logicalBottom.isAuto()));
 
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
-        logicalBottomValue = logicalBottom.calcValue(containerLogicalHeight);
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
+        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);
 
         LayoutUnit difference = availableSpace - (logicalTopValue + logicalBottomValue);
@@ -3425 +3425 @@
     \*-----------------------------------------------------------------------*/
     } else if (logicalTop.isAuto()) {
-        marginBeforeAlias = marginBefore.calcValue(containerLogicalHeight);
-        marginAfterAlias = marginAfter.calcValue(containerLogicalHeight);
-        logicalBottomValue = logicalBottom.calcValue(containerLogicalHeight);
+        marginBeforeAlias = valueForLength(marginBefore, containerLogicalHeight);
+        marginAfterAlias = valueForLength(marginAfter, containerLogicalHeight);
+        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);
 
         // Solve for 'top'
         logicalTopValue = availableSpace - (logicalBottomValue + marginBeforeAlias + marginAfterAlias);
     } else if (logicalBottom.isAuto()) {
-        marginBeforeAlias = marginBefore.calcValue(containerLogicalHeight);
-        marginAfterAlias = marginAfter.calcValue(containerLogicalHeight);
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
+        marginBeforeAlias = valueForLength(marginBefore, containerLogicalHeight);
+        marginAfterAlias = valueForLength(marginAfter, containerLogicalHeight);
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
 
         // Solve for 'bottom'
@@ -3440 +3440 @@
         // use the value.
     } else if (marginBefore.isAuto()) {
-        marginAfterAlias = marginAfter.calcValue(containerLogicalHeight);
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
-        logicalBottomValue = logicalBottom.calcValue(containerLogicalHeight);
+        marginAfterAlias = valueForLength(marginAfter, containerLogicalHeight);
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
+        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);
 
         // Solve for 'margin-top'
         marginBeforeAlias = availableSpace - (logicalTopValue + logicalBottomValue + marginAfterAlias);
     } else if (marginAfter.isAuto()) {
-        marginBeforeAlias = marginBefore.calcValue(containerLogicalHeight);
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
-        logicalBottomValue = logicalBottom.calcValue(containerLogicalHeight);
+        marginBeforeAlias = valueForLength(marginBefore, containerLogicalHeight);
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
+        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);
 
         // Solve for 'margin-bottom'
@@ -3455 +3455 @@
     } else {
         // Nothing is 'auto', just calculate the values.
-        marginBeforeAlias = marginBefore.calcValue(containerLogicalHeight);
-        marginAfterAlias = marginAfter.calcValue(containerLogicalHeight);
-        logicalTopValue = logicalTop.calcValue(containerLogicalHeight);
+        marginBeforeAlias = valueForLength(marginBefore, containerLogicalHeight);
+        marginAfterAlias = valueForLength(marginAfter, containerLogicalHeight);
+        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
         // NOTE: It is not necessary to solve for 'bottom' because we don't ever
         // use the value.

trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp

@@ -438 +438 @@
         RenderBlock* cb = containingBlock();
         if (!style()->right().isAuto() && !cb->style()->isLeftToRightDirection())
-            return -style()->right().calcValue(cb->availableWidth());
-        return offset + style()->left().calcValue(cb->availableWidth());
+            return -valueForLength(style()->right(), cb->availableWidth());
+        return offset + valueForLength(style()->left(), cb->availableWidth());
     }
     if (!style()->right().isAuto()) {
         RenderBlock* cb = containingBlock();
-        return offset + -style()->right().calcValue(cb->availableWidth());
+        return offset + -valueForLength(style()->right(), cb->availableWidth());
     }
     return offset;
@@ -463 +463 @@
             || !style()->top().isPercent()
             || containingBlock->stretchesToViewport()))
-        return offset + style()->top().calcValue(containingBlock->availableHeight());
+        return offset + valueForLength(style()->top(), containingBlock->availableHeight());
 
     if (!style()->bottom().isAuto()
@@ -469 +469 @@
             || !style()->bottom().isPercent()
             || containingBlock->stretchesToViewport()))
-        return offset + -style()->bottom().calcValue(containingBlock->availableHeight());
+        return offset + -valueForLength(style()->bottom(), containingBlock->availableHeight());
 
     return offset;
@@ -557 +557 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -566 +566 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -575 +575 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -584 +584 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -593 +593 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -602 +602 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -611 +611 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -620 +620 @@
     if (padding.isPercent())
         w = containingBlock()->availableLogicalWidth();
-    return padding.calcMinValue(w);
+    return miminumValueForLength(padding, w);
 }
 
@@ -999 +999 @@
                 w = layerWidth.value();
             else if (layerWidth.isPercent())
-                w = layerWidth.calcValue(positioningAreaSize.width());
+                w = valueForLength(layerWidth, positioningAreaSize.width());
             
             if (layerHeight.isFixed())
                 h = layerHeight.value();
             else if (layerHeight.isPercent())
-                h = layerHeight.calcValue(positioningAreaSize.height());
+                h = valueForLength(layerHeight, positioningAreaSize.height());
             
             // If one of the values is auto we have to use the appropriate
@@ -1140 +1140 @@
     EFillRepeat backgroundRepeatY = fillLayer->repeatY();
 
-    LayoutUnit xPosition = fillLayer->xPosition().calcMinValue(positioningAreaSize.width() - geometry.tileSize().width(), true);
+    LayoutUnit xPosition = miminumValueForLength(fillLayer->xPosition(), positioningAreaSize.width() - geometry.tileSize().width(), true);
     if (backgroundRepeatX == RepeatFill)
         geometry.setPhaseX(geometry.tileSize().width() ? geometry.tileSize().width() - (xPosition + left) % geometry.tileSize().width() : 0);
@@ -1146 +1146 @@
         geometry.setNoRepeatX(xPosition + left);
 
-    LayoutUnit yPosition = fillLayer->yPosition().calcMinValue(positioningAreaSize.height() - geometry.tileSize().height(), true);
+    LayoutUnit yPosition = miminumValueForLength(fillLayer->yPosition(), positioningAreaSize.height() - geometry.tileSize().height(), true);
     if (backgroundRepeatY == RepeatFill)
         geometry.setPhaseY(geometry.tileSize().height() ? geometry.tileSize().height() - (yPosition + top) % geometry.tileSize().height() : 0);
@@ -1165 +1165 @@
     if (borderSlice.isAuto())
         return imageSide;
-    return borderSlice.calcValue(boxExtent);
+    return valueForLength(borderSlice, boxExtent);
 }
 
@@ -1203 +1203 @@
     int imageHeight = imageSize.height() / style->effectiveZoom();
 
-    int topSlice = min<int>(imageHeight, ninePieceImage.imageSlices().top().calcValue(imageHeight));
-    int rightSlice = min<int>(imageWidth, ninePieceImage.imageSlices().right().calcValue(imageWidth));
-    int bottomSlice = min<int>(imageHeight, ninePieceImage.imageSlices().bottom().calcValue(imageHeight));
-    int leftSlice = min<int>(imageWidth, ninePieceImage.imageSlices().left().calcValue(imageWidth));
+    int topSlice = min<int>(imageHeight, valueForLength(ninePieceImage.imageSlices().top(), imageHeight));
+    int rightSlice = min<int>(imageWidth, valueForLength(ninePieceImage.imageSlices().right(), imageWidth));
+    int bottomSlice = min<int>(imageHeight, valueForLength(ninePieceImage.imageSlices().bottom(), imageHeight));
+    int leftSlice = min<int>(imageWidth, valueForLength(ninePieceImage.imageSlices().left(), imageWidth));
 
     ENinePieceImageRule hRule = ninePieceImage.horizontalRule();

trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

@@ -574 +574 @@
         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
     }
-    return mainAxisLength.calcMinValue(mainAxisContentExtent());
+    return miminumValueForLength(mainAxisLength, mainAxisContentExtent());
 }
 
@@ -681 +681 @@
         // computes the start/end margins.
         if (isHorizontalFlow()) {
-            child->setMarginLeft(child->style()->marginLeft().calcMinValue(flexboxAvailableContentExtent));
-            child->setMarginRight(child->style()->marginRight().calcMinValue(flexboxAvailableContentExtent));
+            child->setMarginLeft(miminumValueForLength(child->style()->marginLeft(), flexboxAvailableContentExtent));
+            child->setMarginRight(miminumValueForLength(child->style()->marginRight(), flexboxAvailableContentExtent));
         } else {
-            child->setMarginTop(child->style()->marginTop().calcMinValue(flexboxAvailableContentExtent));
-            child->setMarginBottom(child->style()->marginBottom().calcMinValue(flexboxAvailableContentExtent));
+            child->setMarginTop(miminumValueForLength(child->style()->marginTop(), flexboxAvailableContentExtent));
+            child->setMarginBottom(miminumValueForLength(child->style()->marginBottom(), flexboxAvailableContentExtent));
         }
     }
@@ -759 +759 @@
 
                 Length childLogicalMaxWidth = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
-                if (childLogicalMaxWidth.isSpecified() && childPreferredSize > childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent)) {
-                    childPreferredSize = childLogicalMaxWidth.calcValue(flexboxAvailableContentExtent);
+                if (childLogicalMaxWidth.isSpecified() && childPreferredSize > valueForLength(childLogicalMaxWidth, flexboxAvailableContentExtent)) {
+                    childPreferredSize = valueForLength(childLogicalMaxWidth, flexboxAvailableContentExtent);
                     availableFreeSpace -= childPreferredSize - preferredMainAxisContentExtentForChild(child);
                     totalPositiveFlexibility -= positiveFlexForChild(child);
@@ -771 +771 @@
 
                 Length childLogicalMinWidth = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
-                if (childLogicalMinWidth.isSpecified() && childPreferredSize < childLogicalMinWidth.calcValue(flexboxAvailableContentExtent)) {
-                    childPreferredSize = childLogicalMinWidth.calcValue(flexboxAvailableContentExtent);
+                if (childLogicalMinWidth.isSpecified() && childPreferredSize < valueForLength(childLogicalMinWidth, flexboxAvailableContentExtent)) {
+                    childPreferredSize = valueForLength(childLogicalMinWidth, flexboxAvailableContentExtent);
                     availableFreeSpace += preferredMainAxisContentExtentForChild(child) - childPreferredSize;
                     totalNegativeFlexibility -= negativeFlexForChild(child);

trunk/Source/WebCore/rendering/RenderFrameSet.cpp

@@ -224 +224 @@
         // Count the number of columns/rows which are percentages -> countPercent
         if (grid[i].isPercent()) {
-            gridLayout[i] = max(grid[i].calcValue(availableLen), 0);
+            gridLayout[i] = max(valueForLength(grid[i], availableLen), 0);
             totalPercent += gridLayout[i];
             countPercent++;

trunk/Source/WebCore/rendering/RenderInline.cpp

@@ -702 +702 @@
         return margin.value();
     if (margin.isPercent())
-        return margin.calcMinValue(max<LayoutUnit>(0, renderer->containingBlock()->availableLogicalWidth()));
+        return miminumValueForLength(margin, max<LayoutUnit>(0, renderer->containingBlock()->availableLogicalWidth()));
     return 0;
 }

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -821 +821 @@
     const float boxHeight = borderBox.height();
 
-    float perspectiveOriginX = style->perspectiveOriginX().calcFloatValue(boxWidth);
-    float perspectiveOriginY = style->perspectiveOriginY().calcFloatValue(boxHeight);
+    float perspectiveOriginX = floatValueForLength(style->perspectiveOriginX(), boxWidth);
+    float perspectiveOriginY = floatValueForLength(style->perspectiveOriginY(), boxHeight);
 
     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
@@ -845 +845 @@
     RenderStyle* style = renderer()->style();
 
-    return FloatPoint(style->perspectiveOriginX().calcFloatValue(borderBox.width()),
-                      style->perspectiveOriginY().calcFloatValue(borderBox.height()));
+    return FloatPoint(floatValueForLength(style->perspectiveOriginX(), borderBox.width()),
+                      floatValueForLength(style->perspectiveOriginY(), borderBox.height()));
 }
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -1006 +1006 @@
 
     FloatPoint3D origin;
-    origin.setX(style->transformOriginX().calcFloatValue(borderBox.width()));
-    origin.setY(style->transformOriginY().calcFloatValue(borderBox.height()));
+    origin.setX(floatValueForLength(style->transformOriginX(), borderBox.width()));
+    origin.setY(floatValueForLength(style->transformOriginY(), borderBox.height()));
     origin.setZ(style->transformOriginZ());
 
@@ -1021 +1021 @@
 
     FloatPoint origin;
-    origin.setX(style->perspectiveOriginX().calcFloatValue(boxWidth));
-    origin.setY(style->perspectiveOriginY().calcFloatValue(boxHeight));
+    origin.setX(floatValueForLength(style->perspectiveOriginX(), boxWidth));
+    origin.setY(floatValueForLength(style->perspectiveOriginY(), boxHeight));
 
     return origin;

trunk/Source/WebCore/rendering/RenderMarquee.cpp

@@ -290 +290 @@
         bool positive = range > 0;
         int clientSize = (isHorizontal() ? m_layer->renderBox()->clientWidth() : m_layer->renderBox()->clientHeight());
-        int increment = abs(m_layer->renderer()->style()->marqueeIncrement().calcValue(clientSize));
+        int increment = abs(valueForLength(m_layer->renderer()->style()->marqueeIncrement(), clientSize));
         int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());
         newPos =  currentPos + (addIncrement ? increment : -increment);

trunk/Source/WebCore/rendering/RenderMenuList.cpp

@@ -162 +162 @@
             float optionWidth = 0;
             if (RenderStyle* optionStyle = element->renderStyle())
-                optionWidth += optionStyle->textIndent().calcMinValue(0);
+                optionWidth += miminumValueForLength(optionStyle->textIndent(), 0);
             if (!text.isEmpty())
                 optionWidth += style()->font().width(text);

trunk/Source/WebCore/rendering/RenderObject.cpp

@@ -1446 +1446 @@
         int borderRight = isBox() ? toRenderBox(this)->borderRight() : 0;
         LayoutUnit boxWidth = isBox() ? toRenderBox(this)->width() : zeroLayoutUnit;
-        LayoutUnit borderWidth = max<LayoutUnit>(-outlineStyle->outlineOffset(), max<LayoutUnit>(borderRight, max<LayoutUnit>(style()->borderTopRightRadius().width().calcValue(boxWidth), style()->borderBottomRightRadius().width().calcValue(boxWidth)))) + max<LayoutUnit>(ow, shadowRight);
+        LayoutUnit borderWidth = max<LayoutUnit>(-outlineStyle->outlineOffset(), max<LayoutUnit>(borderRight, max<LayoutUnit>(valueForLength(style()->borderTopRightRadius().width(), boxWidth), valueForLength(style()->borderBottomRightRadius().width(), boxWidth)))) + max<LayoutUnit>(ow, shadowRight);
         LayoutRect rightRect(newOutlineBox.x() + min(newOutlineBox.width(), oldOutlineBox.width()) - borderWidth,
             newOutlineBox.y(),
@@ -1465 +1465 @@
         int borderBottom = isBox() ? toRenderBox(this)->borderBottom() : 0;
         LayoutUnit boxHeight = isBox() ? toRenderBox(this)->height() : zeroLayoutUnit;
-        LayoutUnit borderHeight = max<LayoutUnit>(-outlineStyle->outlineOffset(), max<LayoutUnit>(borderBottom, max<LayoutUnit>(style()->borderBottomLeftRadius().height().calcValue(boxHeight), style()->borderBottomRightRadius().height().calcValue(boxHeight)))) + max<LayoutUnit>(ow, shadowBottom);
+        LayoutUnit borderHeight = max<LayoutUnit>(-outlineStyle->outlineOffset(), max<LayoutUnit>(borderBottom, max<LayoutUnit>(valueForLength(style()->borderBottomLeftRadius().height(), boxHeight), valueForLength(style()->borderBottomRightRadius().height(), boxHeight)))) + max<LayoutUnit>(ow, shadowBottom);
         LayoutRect bottomRect(newOutlineBox.x(),
             min(newOutlineBox.maxY(), oldOutlineBox.maxY()) - borderHeight,

trunk/Source/WebCore/rendering/RenderReplaced.cpp

@@ -336 +336 @@
 
                 // This solves above equation for 'width' (== logicalWidth).
-                LayoutUnit marginStart = style()->marginStart().calcMinValue(logicalWidth);
-                LayoutUnit marginEnd = style()->marginEnd().calcMinValue(logicalWidth);
+                LayoutUnit marginStart = miminumValueForLength(style()->marginStart(), logicalWidth);
+                LayoutUnit marginEnd = miminumValueForLength(style()->marginEnd(), logicalWidth);
                 logicalWidth = max(0, logicalWidth - (marginStart + marginEnd + (width() - clientWidth())));
                 if (isPercentageIntrinsicSize)

trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp

@@ -84 +84 @@
     if (l.isIntrinsicOrAuto())
         return ScrollbarTheme::theme()->scrollbarThickness();
-    return l.calcMinValue(containingLength);
+    return miminumValueForLength(l, containingLength);
 }
 
@@ -98 +98 @@
     
     // Buttons and track pieces can all have margins along the axis of the scrollbar. 
-    m_marginLeft = style()->marginLeft().calcMinValue(visibleSize);
-    m_marginRight = style()->marginRight().calcMinValue(visibleSize);
+    m_marginLeft = miminumValueForLength(style()->marginLeft(), visibleSize);
+    m_marginRight = miminumValueForLength(style()->marginRight(), visibleSize);
 }
 
@@ -113 +113 @@
 
     // Buttons and track pieces can all have margins along the axis of the scrollbar. 
-    m_marginTop = style()->marginTop().calcMinValue(visibleSize);
-    m_marginBottom = style()->marginBottom().calcMinValue(visibleSize);
+    m_marginTop = miminumValueForLength(style()->marginTop(), visibleSize);
+    m_marginBottom = miminumValueForLength(style()->marginBottom(), visibleSize);
 }
 

trunk/Source/WebCore/rendering/RenderTable.cpp

@@ -233 +233 @@
     else {
         // Subtract out any fixed margins from our available width for auto width tables.
-        LayoutUnit marginStart = style()->marginStart().calcMinValue(availableLogicalWidth);
-        LayoutUnit marginEnd = style()->marginEnd().calcMinValue(availableLogicalWidth);
+        LayoutUnit marginStart = miminumValueForLength(style()->marginStart(), availableLogicalWidth);
+        LayoutUnit marginEnd = miminumValueForLength(style()->marginEnd(), availableLogicalWidth);
         LayoutUnit marginTotal = marginStart + marginEnd;
         
@@ -262 +262 @@
         computeInlineDirectionMargins(cb, availableLogicalWidth, logicalWidth());
     else {
-        setMarginStart(style()->marginStart().calcMinValue(availableLogicalWidth));
-        setMarginEnd(style()->marginEnd().calcMinValue(availableLogicalWidth));
+        setMarginStart(miminumValueForLength(style()->marginStart(), availableLogicalWidth));
+        setMarginEnd(miminumValueForLength(style()->marginEnd(), availableLogicalWidth));
     }
 }
@@ -277 +277 @@
         borders = borderStart() + borderEnd() + (collapseBorders() ? 0 : paddingStart() + paddingEnd());
     }
-    return styleLogicalWidth.calcMinValue(availableWidth) + borders;
+    return miminumValueForLength(styleLogicalWidth, availableWidth) + borders;
 }
 

trunk/Source/WebCore/rendering/RenderTableCell.cpp

@@ -96 +96 @@
     LayoutUnit adjustedLogicalHeight = logicalHeight() - (intrinsicPaddingBefore() + intrinsicPaddingAfter());
 
-    LayoutUnit styleLogicalHeight = style()->logicalHeight().calcValue(0);
+    LayoutUnit styleLogicalHeight = valueForLength(style()->logicalHeight(), 0);
     if (document()->inQuirksMode() || style()->boxSizing() == BORDER_BOX) {
         // Explicit heights use the border box in quirks mode.

trunk/Source/WebCore/rendering/RenderTableSection.cpp

@@ -339 +339 @@
 
         // Our base size is the biggest logical height from our cells' styles (excluding row spanning cells).
-        m_rowPos[r + 1] = max(m_rowPos[r] + m_grid[r].logicalHeight.calcMinValue(0), 0);
+        m_rowPos[r + 1] = max(m_rowPos[r] + miminumValueForLength(m_grid[r].logicalHeight, 0), 0);
 
         Row& row = m_grid[r].row;

trunk/Source/WebCore/rendering/RenderText.h

@@ -98 +98 @@
     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0);
 
-    virtual LayoutUnit marginLeft() const { return style()->marginLeft().calcMinValue(0); }
-    virtual LayoutUnit marginRight() const { return style()->marginRight().calcMinValue(0); }
+    virtual LayoutUnit marginLeft() const { return miminumValueForLength(style()->marginLeft(), 0); }
+    virtual LayoutUnit marginRight() const { return miminumValueForLength(style()->marginRight(), 0); }
 
     virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;

trunk/Source/WebCore/rendering/RootInlineBox.cpp

@@ -845 +845 @@
             verticalPosition += -renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection);
         else if (verticalAlign == LENGTH)
-            verticalPosition -= renderer->style()->verticalAlignLength().calcValue(renderer->lineHeight(firstLine, lineDirection));
+            verticalPosition -= valueForLength(renderer->style()->verticalAlignLength(), renderer->lineHeight(firstLine, lineDirection));
     }
 

trunk/Source/WebCore/rendering/style/RenderStyle.cpp

@@ -803 +803 @@
 
     if (applyTransformOrigin)
-        transform.translate3d(transformOriginX().calcFloatValue(borderBoxSize.width()), transformOriginY().calcFloatValue(borderBoxSize.height()), transformOriginZ());
+        transform.translate3d(floatValueForLength(transformOriginX(), borderBoxSize.width()), floatValueForLength(transformOriginY(), borderBoxSize.height()), transformOriginZ());
 
     unsigned size = transformOperations.size();
@@ -810 +810 @@
 
     if (applyTransformOrigin)
-        transform.translate3d(-transformOriginX().calcFloatValue(borderBoxSize.width()), -transformOriginY().calcFloatValue(borderBoxSize.height()), -transformOriginZ()); 
+        transform.translate3d(-floatValueForLength(transformOriginX(), borderBoxSize.width()), -floatValueForLength(transformOriginY(), borderBoxSize.height()), -transformOriginZ()); 
 }
 
@@ -822 +822 @@
     
     if (applyTransformOrigin) {
-        transform.translate3d(transformOriginX().calcFloatValue(boundingBox.width()) + offsetX,
-                              transformOriginY().calcFloatValue(boundingBox.height()) + offsetY,
+        transform.translate3d(floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX,
+                              floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY,
                               transformOriginZ());
     }
@@ -832 +832 @@
     
     if (applyTransformOrigin) {
-        transform.translate3d(-transformOriginX().calcFloatValue(boundingBox.width()) - offsetX,
-                              -transformOriginY().calcFloatValue(boundingBox.height()) - offsetY,
+        transform.translate3d(-floatValueForLength(transformOriginX(), boundingBox.width()) - offsetX,
+                              -floatValueForLength(transformOriginY(), boundingBox.height()) - offsetY,
                               -transformOriginZ());
     }
@@ -878 +878 @@
 {
     return RoundedRect::Radii(
-        IntSize(border.topLeft().width().calcValue(size.width()), 
-                border.topLeft().height().calcValue(size.height())),
-        IntSize(border.topRight().width().calcValue(size.width()),
-                border.topRight().height().calcValue(size.height())),
-        IntSize(border.bottomLeft().width().calcValue(size.width()), 
-                border.bottomLeft().height().calcValue(size.height())),
-        IntSize(border.bottomRight().width().calcValue(size.width()), 
-                border.bottomRight().height().calcValue(size.height())));
+        IntSize(valueForLength(border.topLeft().width(), size.width()), 
+                valueForLength(border.topLeft().height(), size.height())),
+        IntSize(valueForLength(border.topRight().width(), size.width()),
+                valueForLength(border.topRight().height(), size.height())),
+        IntSize(valueForLength(border.bottomLeft().width(), size.width()), 
+                valueForLength(border.bottomLeft().height(), size.height())),
+        IntSize(valueForLength(border.bottomRight().width(), size.width()), 
+                valueForLength(border.bottomRight().height(), size.height())));
 }
 

trunk/Source/WebCore/rendering/style/RenderStyle.h

@@ -40 +40 @@
 #include "Length.h"
 #include "LengthBox.h"
+#include "LengthFunctions.h"
 #include "LengthSize.h"
 #include "LineClampValue.h"
@@ -631 +632 @@
 
         if (lh.isPercent())
-            return lh.calcMinValue(fontSize());
+            return miminumValueForLength(lh, fontSize());
 
         return lh.value();

trunk/Source/WebCore/rendering/svg/RenderSVGRoot.cpp

@@ -88 +88 @@
     if (intrinsicWidthAttribute.isFixed() || intrinsicHeightAttribute.isFixed()) {
         if (intrinsicWidthAttribute.isFixed())
-            intrinsicSize.setWidth(intrinsicWidthAttribute.calcFloatValue(0));
+            intrinsicSize.setWidth(floatValueForLength(intrinsicWidthAttribute, 0));
         if (intrinsicHeightAttribute.isFixed())
-            intrinsicSize.setHeight(intrinsicHeightAttribute.calcFloatValue(0));
+            intrinsicSize.setHeight(floatValueForLength(intrinsicHeightAttribute, 0));
         if (!intrinsicSize.isEmpty())
             intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
@@ -154 +154 @@
 static inline LayoutUnit resolveLengthAttributeForSVG(const Length& length, float scale, float maxSize)
 {
-    return static_cast<LayoutUnit>(length.calcValue(maxSize) * (length.isFixed() ? scale : 1));
+    return static_cast<LayoutUnit>(valueForLength(length, maxSize) * (length.isFixed() ? scale : 1));
 }
 

trunk/Source/WebCore/svg/SVGSVGElement.cpp

@@ -542 +542 @@
     // 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(intrinsicWidth.calcFloatValue(0), intrinsicHeight.calcFloatValue(0)));
+    return FloatRect(FloatPoint(), FloatSize(floatValueForLength(intrinsicWidth, 0), floatValueForLength(intrinsicHeight, 0)));
 }
 
@@ -550 +550 @@
     Length intrinsicHeight = this->intrinsicHeight();
     if (intrinsicWidth.isFixed() && intrinsicHeight.isFixed())
-        return FloatSize(intrinsicWidth.calcFloatValue(0), intrinsicHeight.calcFloatValue(0));
+        return FloatSize(floatValueForLength(intrinsicWidth, 0), floatValueForLength(intrinsicHeight, 0));
 
     if (!renderer())

trunk/Source/WebCore/svg/graphics/SVGImage.cpp

@@ -294 +294 @@
     intrinsicRatio = rootElement->viewBox().size();
     if (intrinsicRatio.isEmpty() && intrinsicWidth.isFixed() && intrinsicHeight.isFixed())
-        intrinsicRatio = FloatSize(intrinsicWidth.calcFloatValue(0), intrinsicHeight.calcFloatValue(0));
+        intrinsicRatio = FloatSize(floatValueForLength(intrinsicWidth, 0), floatValueForLength(intrinsicHeight, 0));
 }
 

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2012-03-17  Joe Thomas  <joethomas@motorola.com>
+
+        move calc*Value functions out from Length (and platform)
+        https://bugs.webkit.org/show_bug.cgi?id=80897
+
+        Moving the Length calc*Value functions out from Length structure and also from /WebCore/platform/ folder.
+        This helps to avoid the layering violation while length calculation. Otherwise layer violation can be avoided only by adding a virtual interface(bug 27160).
+
+        Reviewed by Antti Koivisto.
+
+        * WebProcess/WebCoreSupport/win/WebPopupMenuWin.cpp:
+        (WebKit::WebPopupMenu::setUpPlatformData):
+
 2012-03-17  Dan Bernstein  <mitz@apple.com>
 

trunk/Source/WebKit2/WebProcess/WebCoreSupport/win/WebPopupMenuWin.cpp

@@ -30 +30 @@
 #include <WebCore/Font.h>
 #include <WebCore/GraphicsContext.h>
+#include <WebCore/LengthFunctions.h>
 #include <WebCore/TextRun.h>
 #include <WebCore/PopupMenuClient.h>
@@ -136 +137 @@
             int textX = std::max(0, data.m_clientPaddingLeft - data.m_clientInsetLeft);
             if (RenderTheme::defaultTheme()->popupOptionSupportsTextIndent() && itemStyle.textDirection() == LTR)
-                textX += itemStyle.textIndent().calcMinValue(itemRect.width());
+                textX += miminumValueForLength(itemStyle.textIndent(), itemRect.width());
             int textY = itemRect.y() + itemFont.fontMetrics().ascent() + (itemRect.height() - itemFont.fontMetrics().height()) / 2;