Wrap CSS length conversion arguments in an object

Source/core/css/resolver/TransformBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 33 matching lines @@
 namespace WebCore {
 
 TransformBuilder::TransformBuilder()
 {
 }
 
 TransformBuilder::~TransformBuilder()
 {
 }
 
-static Length convertToFloatLength(CSSPrimitiveValue* primitiveValue, const RenderStyle* style, const RenderStyle* rootStyle, double multiplier)
+static Length convertToFloatLength(CSSPrimitiveValue* primitiveValue, const CSSToLengthConversionData& conversionData)
 {
-    return primitiveValue ? primitiveValue->convertToLength<FixedConversion | PercentConversion>(style, rootStyle, multiplier) : Length(Undefined);
+    return primitiveValue ? primitiveValue->convertToLength<FixedConversion | PercentConversion>(conversionData) : Length(Undefined);
 }
 
 static TransformOperation::OperationType getTransformOperationType(CSSTransformValue::TransformOperationType type)
 {
     switch (type) {
     case CSSTransformValue::ScaleTransformOperation: return TransformOperation::Scale;
     case CSSTransformValue::ScaleXTransformOperation: return TransformOperation::ScaleX;
     case CSSTransformValue::ScaleYTransformOperation: return TransformOperation::ScaleY;
     case CSSTransformValue::ScaleZTransformOperation: return TransformOperation::ScaleZ;
     case CSSTransformValue::Scale3DTransformOperation: return TransformOperation::Scale3D;
@@ skipping 11 matching lines @@
     case CSSTransformValue::SkewXTransformOperation: return TransformOperation::SkewX;
     case CSSTransformValue::SkewYTransformOperation: return TransformOperation::SkewY;
     case CSSTransformValue::MatrixTransformOperation: return TransformOperation::Matrix;
     case CSSTransformValue::Matrix3DTransformOperation: return TransformOperation::Matrix3D;
     case CSSTransformValue::PerspectiveTransformOperation: return TransformOperation::Perspective;
     case CSSTransformValue::UnknownTransformOperation: return TransformOperation::None;
     }
     return TransformOperation::None;
 }
 
-bool TransformBuilder::createTransformOperations(CSSValue* inValue, const RenderStyle* style, const RenderStyle* rootStyle, TransformOperations& outOperations)
+bool TransformBuilder::createTransformOperations(CSSValue* inValue, const CSSToLengthConversionData& conversionData, TransformOperations& outOperations)
 {
     if (!inValue || !inValue->isValueList()) {
         outOperations.clear();
         return false;
     }
 
-    float zoomFactor = style ? style->effectiveZoom() : 1;
+    float zoomFactor = conversionData.zoom();
     TransformOperations operations;
     for (CSSValueListIterator i = inValue; i.hasMore(); i.advance()) {
         CSSValue* currValue = i.value();
 
         if (!currValue->isTransformValue())
             continue;
 
         CSSTransformValue* transformValue = toCSSTransformValue(i.value());
         if (!transformValue->length())
             continue;
@@ skipping 56 matching lines @@
             }
             operations.operations().append(ScaleTransformOperation::create(sx, sy, sz, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::TranslateTransformOperation:
         case CSSTransformValue::TranslateXTransformOperation:
         case CSSTransformValue::TranslateYTransformOperation: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
-                ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                ty = convertToFloatLength(firstValue, conversionData);
             else {
-                tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                tx = convertToFloatLength(firstValue, conversionData);
                 if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
                     if (transformValue->length() > 1) {
                         CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
-                        ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
+                        ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
             if (tx.isUndefined() || ty.isUndefined())
                 return false;
 
             operations.operations().append(TranslateTransformOperation::create(tx, ty, Length(0, Fixed), getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::TranslateZTransformOperation:
         case CSSTransformValue::Translate3DTransformOperation: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             Length tz = Length(0, Fixed);
             if (transformValue->operationType() == CSSTransformValue::TranslateZTransformOperation)
-                tz = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                tz = convertToFloatLength(firstValue, conversionData);
             else if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
-                ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                ty = convertToFloatLength(firstValue, conversionData);
             else {
-                tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                tx = convertToFloatLength(firstValue, conversionData);
                 if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
                     if (transformValue->length() > 2) {
                         CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
-                        tz = convertToFloatLength(thirdValue, style, rootStyle, zoomFactor);
+                        tz = convertToFloatLength(thirdValue, conversionData);
                     }
                     if (transformValue->length() > 1) {
                         CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
-                        ty = convertToFloatLength(secondValue, style, rootStyle, zoomFactor);
+                        ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
             if (tx.isUndefined() || ty.isUndefined() || tz.isUndefined())
                 return false;
 
             operations.operations().append(TranslateTransformOperation::create(tx, ty, tz, getTransformOperationType(transformValue->operationType())));
             break;
         }
@@ skipping 82 matching lines @@
                 zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(12))->getDoubleValue(),
                 zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(13))->getDoubleValue(),
                 toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(14))->getDoubleValue(),
                 toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(15))->getDoubleValue());
             operations.operations().append(Matrix3DTransformOperation::create(matrix));
             break;
         }
         case CSSTransformValue::PerspectiveTransformOperation: {
             Length p = Length(0, Fixed);
             if (firstValue->isLength())
-                p = convertToFloatLength(firstValue, style, rootStyle, zoomFactor);
+                p = convertToFloatLength(firstValue, conversionData);
             else {
                 // This is a quirk that should go away when 3d transforms are finalized.
                 double val = firstValue->getDoubleValue();
                 p = val >= 0 ? Length(clampToPositiveInteger(val), Fixed) : Length(Undefined);
             }
 
             if (p.isUndefined())
                 return false;
 
             operations.operations().append(PerspectiveTransformOperation::create(p));
             break;
         }
         case CSSTransformValue::UnknownTransformOperation:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     outOperations = operations;
     return true;
 }
 
 } // namespace WebCore