Make vw/vh units to work in css transforms.

Source/core/platform/graphics/chromium/AnimationTranslationUtil.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 38 matching lines @@
 #include "public/platform/WebTransformOperations.h"
 
 #include "wtf/OwnPtr.h"
 #include "wtf/text/CString.h"
 
 using namespace std;
 using namespace WebKit;
 
 namespace WebCore {
 
-PassOwnPtr<WebTransformOperations> toWebTransformOperations(const TransformOperations& transformOperations, const FloatSize& boxSize)
+PassOwnPtr<WebTransformOperations> toWebTransformOperations(const TransformOperations& transformOperations, const FloatSize& boxSize, RenderView* renderView)
 {
     // We need to do a deep copy the transformOperations may contain ref pointers to TransformOperation objects.
     OwnPtr<WebTransformOperations> webTransformOperations = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());
     if (!webTransformOperations)
         return nullptr;
     for (size_t j = 0; j < transformOperations.size(); ++j) {
         TransformOperation::OperationType operationType = transformOperations.operations()[j]->getOperationType();
         switch (operationType) {
         case TransformOperation::ScaleX:
         case TransformOperation::ScaleY:
         case TransformOperation::ScaleZ:
         case TransformOperation::Scale3D:
         case TransformOperation::Scale: {
             ScaleTransformOperation* transform = static_cast<ScaleTransformOperation*>(transformOperations.operations()[j].get());
             webTransformOperations->appendScale(transform->x(), transform->y(), transform->z());
             break;
         }
         case TransformOperation::TranslateX:
         case TransformOperation::TranslateY:
         case TransformOperation::TranslateZ:
         case TransformOperation::Translate3D:
         case TransformOperation::Translate: {
             TranslateTransformOperation* transform = static_cast<TranslateTransformOperation*>(transformOperations.operations()[j].get());
-            webTransformOperations->appendTranslate(floatValueForLength(transform->x(), boxSize.width()), floatValueForLength(transform->y(), boxSize.height()), floatValueForLength(transform->z(), 1));
+            webTransformOperations->appendTranslate(floatValueForLength(transform->x(), boxSize.width(), renderView), floatValueForLength(transform->y(), boxSize.height(), renderView), floatValueForLength(transform->z(), 1, renderView));
             break;
         }
         case TransformOperation::RotateX:
         case TransformOperation::RotateY:
         case TransformOperation::Rotate3D:
         case TransformOperation::Rotate: {
             RotateTransformOperation* transform = static_cast<RotateTransformOperation*>(transformOperations.operations()[j].get());
             webTransformOperations->appendRotate(transform->x(), transform->y(), transform->z(), transform->angle());
             break;
         }
@@ skipping 16 matching lines @@
             webTransformOperations->appendMatrix(TransformSkMatrix44Conversions::convert(m));
             break;
         }
         case TransformOperation::Perspective: {
             PerspectiveTransformOperation* transform = static_cast<PerspectiveTransformOperation*>(transformOperations.operations()[j].get());
             webTransformOperations->appendPerspective(floatValueForLength(transform->perspective(), 0));
             break;
         }
         case TransformOperation::Interpolated: {
             TransformationMatrix m;
-            transformOperations.operations()[j]->apply(m, boxSize);
+            transformOperations.operations()[j]->apply(m, boxSize, renderView);
             webTransformOperations->appendMatrix(TransformSkMatrix44Conversions::convert(m));
             break;
         }
         case TransformOperation::Identity:
             webTransformOperations->appendIdentity();
             break;
         case TransformOperation::None:
             // Do nothing.
             break;
         } // switch
     } // for each operation
 
     return webTransformOperations.release();
 }
 
 template <class Value, class Keyframe, class Curve>
-bool appendKeyframeWithStandardTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize&)
+bool appendKeyframeWithStandardTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize&, RenderView* renderView)
 {
     curve->add(Keyframe(keyTime, value->value()), timingFunctionType);
     return true;
 }
 
 template <class Value, class Keyframe, class Curve>
-bool appendKeyframeWithCustomBezierTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, double x1, double y1, double x2, double y2, const FloatSize&)
+bool appendKeyframeWithCustomBezierTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, double x1, double y1, double x2, double y2, const FloatSize&, RenderView* renderView)
 {
     curve->add(Keyframe(keyTime, value->value()), x1, y1, x2, y2);
     return true;
 }
 
 bool isRotationType(TransformOperation::OperationType transformType)
 {
     return transformType == TransformOperation::Rotate
         || transformType == TransformOperation::RotateX
         || transformType == TransformOperation::RotateY
         || transformType == TransformOperation::RotateZ
         || transformType == TransformOperation::Rotate3D;
 }
 
 template <>
-bool appendKeyframeWithStandardTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize)
+bool appendKeyframeWithStandardTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize, RenderView* renderView)
 {
     bool canBlend = !lastValue;
-    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize));
+    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize, renderView));
     if (!operations)
         return false;
     if (!canBlend) {
-        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize));
+        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize, renderView));
         if (!lastOperations)
             return false;
         canBlend = lastOperations->canBlendWith(*operations);
     }
     if (canBlend) {
         curve->add(WebTransformKeyframe(keyTime, operations.leakPtr()), timingFunctionType);
         return true;
     }
     return false;
 }
 
 template <>
-bool appendKeyframeWithCustomBezierTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, double x1, double y1, double x2, double y2, const FloatSize& boxSize)
+bool appendKeyframeWithCustomBezierTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, double x1, double y1, double x2, double y2, const FloatSize& boxSize, RenderView* renderView)
 {
     bool canBlend = !lastValue;
-    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize));
+    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize, renderView));
     if (!operations)
         return false;
     if (!canBlend) {
-        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize));
+        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize, renderView));
         if (!lastOperations)
             return false;
         canBlend = lastOperations->canBlendWith(*operations);
     }
     if (canBlend) {
         curve->add(WebTransformKeyframe(keyTime, operations.leakPtr()), x1, y1, x2, y2);
         return true;
     }
     return false;
 }
 
 template <class Value, class Keyframe, class Curve>
-PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& valueList, const CSSAnimationData* animation, int animationId, double timeOffset, Curve* curve, WebKit::WebAnimation::TargetProperty targetProperty, const FloatSize& boxSize)
+PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& valueList, const CSSAnimationData* animation, int animationId, double timeOffset, Curve* curve, WebKit::WebAnimation::TargetProperty targetProperty, const FloatSize& boxSize, RenderView* renderView)
 {
     bool alternate = false;
     bool reverse = false;
     if (animation && animation->isDirectionSet()) {
         CSSAnimationData::AnimationDirection direction = animation->direction();
         if (direction == CSSAnimationData::AnimationDirectionAlternate || direction == CSSAnimationData::AnimationDirectionAlternateReverse)
             alternate = true;
         if (direction == CSSAnimationData::AnimationDirectionReverse || direction == CSSAnimationData::AnimationDirectionAlternateReverse)
             reverse = true;
     }
@@ skipping 41 matching lines @@
         }
 
         double duration = (animation && animation->isDurationSet()) ? animation->duration() : 1;
         double keyTime = originalValue->keyTime() * duration;
 
         if (reverse)
             keyTime = duration - keyTime;
 
         bool addedKeyframe = false;
         if (isUsingCustomBezierTimingFunction)
-            addedKeyframe = appendKeyframeWithCustomBezierTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, x1, y1, x2, y2, boxSize);
+            addedKeyframe = appendKeyframeWithCustomBezierTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, x1, y1, x2, y2, boxSize, renderView);
         else
-            addedKeyframe = appendKeyframeWithStandardTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, timingFunctionType, boxSize);
+            addedKeyframe = appendKeyframeWithStandardTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, timingFunctionType, boxSize, renderView);
         if (!addedKeyframe)
             return nullptr;
     }
 
     OwnPtr<WebKit::WebAnimation> webAnimation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty, animationId));
 
     int iterations = (animation && animation->isIterationCountSet()) ? animation->iterationCount() : 1;
     webAnimation->setIterations(iterations);
     webAnimation->setAlternatesDirection(alternate);
 
     // If timeOffset > 0, then the animation has started in the past.
     webAnimation->setTimeOffset(timeOffset);
 
     return webAnimation.release();
 }
 
-PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& values, const CSSAnimationData* animation, int animationId, double timeOffset, const FloatSize& boxSize)
+PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& values, const CSSAnimationData* animation, int animationId, double timeOffset, const FloatSize& boxSize, RenderView* renderView)
 {
 
 
     if (values.property() == AnimatedPropertyWebkitTransform) {
         OwnPtr<WebTransformAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createTransformAnimationCurve());
-        return createWebAnimation<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyTransform, FloatSize(boxSize));
+        return createWebAnimation<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyTransform, FloatSize(boxSize), renderView);
     }
 
     if (values.property() == AnimatedPropertyOpacity) {
         OwnPtr<WebFloatAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createFloatAnimationCurve());
-        return createWebAnimation<FloatAnimationValue, WebFloatKeyframe, WebFloatAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyOpacity, FloatSize());
+        return createWebAnimation<FloatAnimationValue, WebFloatKeyframe, WebFloatAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyOpacity, FloatSize(), renderView);
     }
 
     return nullptr;
 }
 
 } // namespace WebCore