webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 20 insertions, 108 deletions

diff --git a/Source/WebCore/css/LengthFunctions.cpp b/Source/WebCore/css/LengthFunctions.cpp
index adba10081..68fffdeb9 100644
--- a/Source/WebCore/css/LengthFunctions.cpp
+++ b/Source/WebCore/css/LengthFunctions.cpp
@@ -24,57 +24,27 @@
 #include "config.h"
 #include "LengthFunctions.h"
 
-#include "LayoutUnit.h"
-#include "Length.h"
-#include "RenderView.h"
+#include "FloatSize.h"
+#include "LayoutSize.h"
+#include "LengthSize.h"
 
 namespace WebCore {
 
-int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
+int intValueForLength(const Length& length, LayoutUnit maximumValue)
 {
-    return static_cast<int>(minimumValueForLength(length, maximumValue, renderView, roundPercentages));
+    return static_cast<int>(valueForLength(length, maximumValue));
 }
 
-int intValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
-{
-    return static_cast<int>(valueForLength(length, maximumValue, renderView, roundPercentages));
-}
-
-LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
+LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue)
 {
     switch (length.type()) {
     case Fixed:
-        return length.value();
     case Percent:
-        if (roundPercentages)
-            return static_cast<LayoutUnit>(round(maximumValue * length.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<LayoutUnit>(static_cast<float>(maximumValue * length.percent() / 100.0f));
     case Calculated:
-        return length.nonNanCalculatedValue(maximumValue);
-    case ViewportPercentageWidth:
-        if (renderView)
-            return static_cast<LayoutUnit>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageHeight:
-        if (renderView)
-            return static_cast<LayoutUnit>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageMin:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
-    case ViewportPercentageMax:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
+        return minimumValueForLength(length, maximumValue);
     case FillAvailable:
     case Auto:
-        return 0;
+        return maximumValue;
     case Relative:
     case Intrinsic:
     case MinIntrinsic:
@@ -89,67 +59,24 @@ LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue,
     return 0;
 }
 
-LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
+LayoutSize sizeForLengthSize(const LengthSize& length, const LayoutSize& maximumValue)
 {
-    switch (length.type()) {
-    case Fixed:
-    case Percent:
-    case Calculated:
-    case ViewportPercentageWidth:
-    case ViewportPercentageHeight:
-    case ViewportPercentageMin:
-    case ViewportPercentageMax:
-        return minimumValueForLength(length, maximumValue, renderView, roundPercentages);
-    case FillAvailable:
-    case Auto:
-        return maximumValue;
-    case Relative:
-    case Intrinsic:
-    case MinIntrinsic:
-    case MinContent:
-    case MaxContent:
-    case FitContent:
-    case Undefined:
-        ASSERT_NOT_REACHED();
-        return 0;
-    }
-    ASSERT_NOT_REACHED();
-    return 0;
+    return { valueForLength(length.width, maximumValue.width()), valueForLength(length.height, maximumValue.height()) };
 }
 
 // FIXME: when subpixel layout is supported this copy of floatValueForLength() can be removed. See bug 71143.
-float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView)
+float floatValueForLength(const Length& length, LayoutUnit maximumValue)
 {
     switch (length.type()) {
     case Fixed:
-        return length.getFloatValue();
+        return length.value();
     case Percent:
         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     case FillAvailable:
     case Auto:
         return static_cast<float>(maximumValue);
     case Calculated:
-        return length.nonNanCalculatedValue(maximumValue);                
-    case ViewportPercentageWidth:
-        if (renderView)
-            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageHeight:
-        if (renderView)
-            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageMin:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
-    case ViewportPercentageMax:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
+        return length.nonNanCalculatedValue(maximumValue);
     case Relative:
     case Intrinsic:
     case MinIntrinsic:
@@ -164,11 +91,11 @@ float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderV
     return 0;
 }
 
-float floatValueForLength(const Length& length, float maximumValue, RenderView* renderView)
+float floatValueForLength(const Length& length, float maximumValue)
 {
     switch (length.type()) {
     case Fixed:
-        return length.getFloatValue();
+        return length.value();
     case Percent:
         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     case FillAvailable:
@@ -176,26 +103,6 @@ float floatValueForLength(const Length& length, float maximumValue, RenderView*
         return static_cast<float>(maximumValue);
     case Calculated:
         return length.nonNanCalculatedValue(maximumValue);
-    case ViewportPercentageWidth:
-        if (renderView)
-            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageHeight:
-        if (renderView)
-            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
-        return 0;
-    case ViewportPercentageMin:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
-    case ViewportPercentageMax:
-        if (renderView) {
-            IntSize viewportSize = renderView->viewportSize();
-            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
-        }
-        return 0;
     case Relative:
     case Intrinsic:
     case MinIntrinsic:
@@ -210,4 +117,9 @@ float floatValueForLength(const Length& length, float maximumValue, RenderView*
     return 0;
 }
 
+FloatSize floatSizeForLengthSize(const LengthSize& lengthSize, const FloatSize& boxSize)
+{
+    return { floatValueForLength(lengthSize.width, boxSize.width()), floatValueForLength(lengthSize.height, boxSize.height()) };
+}
+
 } // namespace WebCore