CSS Motion Path: Centre transform-origin on the path

Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 909 matching lines @@
 
 void ComputedStyle::applyTransform(TransformationMatrix& result, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyIndependentTransformProperties applyIndependentTransformProperties) const
 {
     if (!hasMotionPath())
         applyMotionPath = ExcludeMotionPath;
     bool applyTransformOrigin = requireTransformOrigin(applyOrigin, applyMotionPath);
 
     float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;
     float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;
 
+    float originX = 0;
+    float originY = 0;
+    float originZ = 0;
+
     if (applyTransformOrigin) {
-        result.translate3d(floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX,
-            floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY,
-            transformOriginZ());
+        originX = floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX;
+        originY = floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY;
+        originZ = transformOriginZ();
+        result.translate3d(originX, originY, originZ);
     }
 
     if (applyIndependentTransformProperties == IncludeIndependentTransformProperties) {
         if (translate())
             translate()->apply(result, boundingBox.size());
 
         if (rotate())
             rotate()->apply(result, boundingBox.size());
 
         if (scale())
             scale()->apply(result, boundingBox.size());
     }
 
     if (applyMotionPath == ComputedStyle::IncludeMotionPath)
-        applyMotionPathTransform(result);
+        applyMotionPathTransform(originX, originY, result);
 
     const Vector<RefPtr<TransformOperation>>& transformOperations = transform().operations();
     unsigned size = transformOperations.size();
     for (unsigned i = 0; i < size; ++i)
         transformOperations[i]->apply(result, boundingBox.size());
 
     if (applyTransformOrigin) {
-        result.translate3d(-floatValueForLength(transformOriginX(), boundingBox.width()) - offsetX,
-            -floatValueForLength(transformOriginY(), boundingBox.height()) - offsetY,
-            -transformOriginZ());
+        result.translate3d(-originX, -originY, -originZ);
     }
 }
 
-void ComputedStyle::applyMotionPathTransform(TransformationMatrix& transform) const
+void ComputedStyle::applyMotionPathTransform(float originX, float originY, TransformationMatrix& transform) const
 {
     const StyleMotionData& motionData = rareNonInheritedData->m_transform->m_motion;
     ASSERT(motionData.m_path && motionData.m_path->isPathStyleMotionPath());
     const PathStyleMotionPath& motionPath = toPathStyleMotionPath(*motionData.m_path);
     float pathLength = motionPath.length();
     float distance = floatValueForLength(motionData.m_offset, pathLength);
     float computedDistance;
     if (motionPath.isClosed() && pathLength > 0) {
         computedDistance = fmod(distance, pathLength);
         if (computedDistance < 0)
             computedDistance += pathLength;
     } else {
         computedDistance = clampTo<float>(distance, 0, pathLength);
     }
 
     FloatPoint point;
     float angle;
     if (!motionPath.path().pointAndNormalAtLength(computedDistance, point, angle))
         return;
     if (motionData.m_rotationType == MotionRotationFixed)
         angle = 0;
 
-    transform.translate(point.x(), point.y());
+    transform.translate(point.x() - originX, point.y() - originY);
     transform.rotate(angle + motionData.m_rotation);
 }
 
 void ComputedStyle::setTextShadow(PassRefPtr<ShadowList> s)
 {
     rareInheritedData.access()->textShadow = s;
 }
 
 void ComputedStyle::setBoxShadow(PassRefPtr<ShadowList> s)
 {
@@ skipping 764 matching lines @@
 }
 
 void ComputedStyle::copyChildDependentFlagsFrom(const ComputedStyle& other)
 {
     setEmptyState(other.emptyState());
     if (other.hasExplicitlyInheritedProperties())
         setHasExplicitlyInheritedProperties();
 }
 
 } // namespace blink