Import Qt5x2 branch of QtWebkit for Qt 5.2

Importing a new snapshot of webkit.

Change-Id: I2d01ad12cdc8af8cb015387641120a9d7ea5f10c
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>

1 files changed, 70 insertions, 31 deletions

diff --git a/Source/WebCore/css/BasicShapeFunctions.cpp b/Source/WebCore/css/BasicShapeFunctions.cpp
index 3a8f7953b..c5885095e 100644
--- a/Source/WebCore/css/BasicShapeFunctions.cpp
+++ b/Source/WebCore/css/BasicShapeFunctions.cpp
@@ -34,7 +34,7 @@
 #include "CSSBasicShapes.h"
 #include "CSSPrimitiveValueMappings.h"
 #include "CSSValuePool.h"
-#include "StyleResolver.h"
+#include "RenderStyle.h"
 
 namespace WebCore {
 
@@ -42,7 +42,7 @@ PassRefPtr<CSSValue> valueForBasicShape(const BasicShape* basicShape)
 {
     RefPtr<CSSBasicShape> basicShapeValue;
     switch (basicShape->type()) {
-    case BasicShape::BASIC_SHAPE_RECTANGLE: {
+    case BasicShape::BasicShapeRectangleType: {
         const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
         RefPtr<CSSBasicShapeRectangle> rectangleValue = CSSBasicShapeRectangle::create();
 
@@ -50,16 +50,13 @@ PassRefPtr<CSSValue> valueForBasicShape(const BasicShape* basicShape)
         rectangleValue->setY(cssValuePool().createValue(rectangle->y()));
         rectangleValue->setWidth(cssValuePool().createValue(rectangle->width()));
         rectangleValue->setHeight(cssValuePool().createValue(rectangle->height()));
-        if (!rectangle->cornerRadiusX().isUndefined()) {
-            rectangleValue->setRadiusX(cssValuePool().createValue(rectangle->cornerRadiusX()));
-            if (!rectangle->cornerRadiusY().isUndefined())
-                rectangleValue->setRadiusY(cssValuePool().createValue(rectangle->cornerRadiusY()));
-        }
+        rectangleValue->setRadiusX(cssValuePool().createValue(rectangle->cornerRadiusX()));
+        rectangleValue->setRadiusY(cssValuePool().createValue(rectangle->cornerRadiusY()));
 
         basicShapeValue = rectangleValue.release();
         break;
     }
-    case BasicShape::BASIC_SHAPE_CIRCLE: {
+    case BasicShape::BasicShapeCircleType: {
         const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
         RefPtr<CSSBasicShapeCircle> circleValue = CSSBasicShapeCircle::create();
 
@@ -70,7 +67,7 @@ PassRefPtr<CSSValue> valueForBasicShape(const BasicShape* basicShape)
         basicShapeValue = circleValue.release();
         break;
     }
-    case BasicShape::BASIC_SHAPE_ELLIPSE: {
+    case BasicShape::BasicShapeEllipseType: {
         const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
         RefPtr<CSSBasicShapeEllipse> ellipseValue = CSSBasicShapeEllipse::create();
 
@@ -82,7 +79,7 @@ PassRefPtr<CSSValue> valueForBasicShape(const BasicShape* basicShape)
         basicShapeValue = ellipseValue.release();
         break;
     }
-    case BasicShape::BASIC_SHAPE_POLYGON: {
+    case BasicShape::BasicShapePolygonType: {
         const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
         RefPtr<CSSBasicShapePolygon> polygonValue = CSSBasicShapePolygon::create();
 
@@ -94,73 +91,115 @@ PassRefPtr<CSSValue> valueForBasicShape(const BasicShape* basicShape)
         basicShapeValue = polygonValue.release();
         break;
     }
+    case BasicShape::BasicShapeInsetRectangleType: {
+        const BasicShapeInsetRectangle* rectangle = static_cast<const BasicShapeInsetRectangle*>(basicShape);
+        RefPtr<CSSBasicShapeInsetRectangle> rectangleValue = CSSBasicShapeInsetRectangle::create();
+
+        rectangleValue->setTop(cssValuePool().createValue(rectangle->top()));
+        rectangleValue->setRight(cssValuePool().createValue(rectangle->right()));
+        rectangleValue->setBottom(cssValuePool().createValue(rectangle->bottom()));
+        rectangleValue->setLeft(cssValuePool().createValue(rectangle->left()));
+        rectangleValue->setRadiusX(cssValuePool().createValue(rectangle->cornerRadiusX()));
+        rectangleValue->setRadiusY(cssValuePool().createValue(rectangle->cornerRadiusY()));
+
+        basicShapeValue = rectangleValue.release();
+        break;
+    }
     default:
         break;
     }
     return cssValuePool().createValue<PassRefPtr<CSSBasicShape> >(basicShapeValue.release());
 }
 
-static Length convertToLength(const StyleResolver* styleResolver, CSSPrimitiveValue* value)
+static Length convertToLength(const RenderStyle* style, const RenderStyle* rootStyle, CSSPrimitiveValue* value)
 {
-    return value->convertToLength<FixedIntegerConversion | FixedFloatConversion | PercentConversion | ViewportPercentageConversion>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());
+    return value->convertToLength<FixedIntegerConversion | FixedFloatConversion | PercentConversion | ViewportPercentageConversion>(style, rootStyle, style->effectiveZoom());
 }
 
-PassRefPtr<BasicShape> basicShapeForValue(const StyleResolver* styleResolver, const CSSBasicShape* basicShapeValue)
+PassRefPtr<BasicShape> basicShapeForValue(const RenderStyle* style, const RenderStyle* rootStyle, const CSSBasicShape* basicShapeValue)
 {
     RefPtr<BasicShape> basicShape;
 
     switch (basicShapeValue->type()) {
-    case CSSBasicShape::CSS_BASIC_SHAPE_RECTANGLE: {
+    case CSSBasicShape::CSSBasicShapeRectangleType: {
         const CSSBasicShapeRectangle* rectValue = static_cast<const CSSBasicShapeRectangle *>(basicShapeValue);
         RefPtr<BasicShapeRectangle> rect = BasicShapeRectangle::create();
 
-        rect->setX(convertToLength(styleResolver, rectValue->x()));
-        rect->setY(convertToLength(styleResolver, rectValue->y()));
-        rect->setWidth(convertToLength(styleResolver, rectValue->width()));
-        rect->setHeight(convertToLength(styleResolver, rectValue->height()));
+        rect->setX(convertToLength(style, rootStyle, rectValue->x()));
+        rect->setY(convertToLength(style, rootStyle, rectValue->y()));
+        rect->setWidth(convertToLength(style, rootStyle, rectValue->width()));
+        rect->setHeight(convertToLength(style, rootStyle, rectValue->height()));
         if (rectValue->radiusX()) {
-            rect->setCornerRadiusX(convertToLength(styleResolver, rectValue->radiusX()));
+            Length radiusX = convertToLength(style, rootStyle, rectValue->radiusX());
+            rect->setCornerRadiusX(radiusX);
             if (rectValue->radiusY())
-                rect->setCornerRadiusY(convertToLength(styleResolver, rectValue->radiusY()));
+                rect->setCornerRadiusY(convertToLength(style, rootStyle, rectValue->radiusY()));
+            else
+                rect->setCornerRadiusY(radiusX);
+        } else {
+            rect->setCornerRadiusX(Length(0, Fixed));
+            rect->setCornerRadiusY(Length(0, Fixed));
         }
         basicShape = rect.release();
         break;
     }
-    case CSSBasicShape::CSS_BASIC_SHAPE_CIRCLE: {
+    case CSSBasicShape::CSSBasicShapeCircleType: {
         const CSSBasicShapeCircle* circleValue = static_cast<const CSSBasicShapeCircle *>(basicShapeValue);
         RefPtr<BasicShapeCircle> circle = BasicShapeCircle::create();
 
-        circle->setCenterX(convertToLength(styleResolver, circleValue->centerX()));
-        circle->setCenterY(convertToLength(styleResolver, circleValue->centerY()));
-        circle->setRadius(convertToLength(styleResolver, circleValue->radius()));
+        circle->setCenterX(convertToLength(style, rootStyle, circleValue->centerX()));
+        circle->setCenterY(convertToLength(style, rootStyle, circleValue->centerY()));
+        circle->setRadius(convertToLength(style, rootStyle, circleValue->radius()));
 
         basicShape = circle.release();
         break;
     }
-    case CSSBasicShape::CSS_BASIC_SHAPE_ELLIPSE: {
+    case CSSBasicShape::CSSBasicShapeEllipseType: {
         const CSSBasicShapeEllipse* ellipseValue = static_cast<const CSSBasicShapeEllipse *>(basicShapeValue);
         RefPtr<BasicShapeEllipse> ellipse = BasicShapeEllipse::create();
 
-        ellipse->setCenterX(convertToLength(styleResolver, ellipseValue->centerX()));
-        ellipse->setCenterY(convertToLength(styleResolver, ellipseValue->centerY()));
-        ellipse->setRadiusX(convertToLength(styleResolver, ellipseValue->radiusX()));
-        ellipse->setRadiusY(convertToLength(styleResolver, ellipseValue->radiusY()));
+        ellipse->setCenterX(convertToLength(style, rootStyle, ellipseValue->centerX()));
+        ellipse->setCenterY(convertToLength(style, rootStyle, ellipseValue->centerY()));
+        ellipse->setRadiusX(convertToLength(style, rootStyle, ellipseValue->radiusX()));
+        ellipse->setRadiusY(convertToLength(style, rootStyle, ellipseValue->radiusY()));
 
         basicShape = ellipse.release();
         break;
     }
-    case CSSBasicShape::CSS_BASIC_SHAPE_POLYGON: {
+    case CSSBasicShape::CSSBasicShapePolygonType: {
         const CSSBasicShapePolygon* polygonValue = static_cast<const CSSBasicShapePolygon *>(basicShapeValue);
         RefPtr<BasicShapePolygon> polygon = BasicShapePolygon::create();
 
         polygon->setWindRule(polygonValue->windRule());
         const Vector<RefPtr<CSSPrimitiveValue> >& values = polygonValue->values();
         for (unsigned i = 0; i < values.size(); i += 2)
-            polygon->appendPoint(convertToLength(styleResolver, values.at(i).get()), convertToLength(styleResolver, values.at(i + 1).get()));
+            polygon->appendPoint(convertToLength(style, rootStyle, values.at(i).get()), convertToLength(style, rootStyle, values.at(i + 1).get()));
 
         basicShape = polygon.release();
         break;
     }
+    case CSSBasicShape::CSSBasicShapeInsetRectangleType: {
+        const CSSBasicShapeInsetRectangle* rectValue = static_cast<const CSSBasicShapeInsetRectangle *>(basicShapeValue);
+        RefPtr<BasicShapeInsetRectangle> rect = BasicShapeInsetRectangle::create();
+
+        rect->setTop(convertToLength(style, rootStyle, rectValue->top()));
+        rect->setRight(convertToLength(style, rootStyle, rectValue->right()));
+        rect->setBottom(convertToLength(style, rootStyle, rectValue->bottom()));
+        rect->setLeft(convertToLength(style, rootStyle, rectValue->left()));
+        if (rectValue->radiusX()) {
+            Length radiusX = convertToLength(style, rootStyle, rectValue->radiusX());
+            rect->setCornerRadiusX(radiusX);
+            if (rectValue->radiusY())
+                rect->setCornerRadiusY(convertToLength(style, rootStyle, rectValue->radiusY()));
+            else
+                rect->setCornerRadiusY(radiusX);
+        } else {
+            rect->setCornerRadiusX(Length(0, Fixed));
+            rect->setCornerRadiusY(Length(0, Fixed));
+        }
+        basicShape = rect.release();
+        break;
+    }
     default:
         break;
     }