CSS Motion Path: New names for properties

third_party/WebKit/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 971 matching lines @@
         case CSSPropertyClipPath:
         case CSSPropertyAliasWebkitClipPath:
         case CSSPropertyWebkitBoxReflect:
         case CSSPropertyFilter:
         case CSSPropertyAliasWebkitFilter:
         case CSSPropertyBackdropFilter:
         case CSSPropertyZIndex:
         case CSSPropertyPosition:
         case CSSPropertyMixBlendMode:
         case CSSPropertyIsolation:
+        case CSSPropertyOffsetPath:

[suzyh_UTC10 (ex-contributor), 2016/09/19 01:21:04]

Is this introducing a behaviour change?

[Eric Willigers, 2016/09/19 01:54:40]

Bug fix, can move to a separate CL.

https://drafts.fxtf.org/motion-1/#offset-path-property
"A computed value of other than none results in the creation of a stacking
context [CSS21] the same way that CSS opacity [CSS3COLOR] does for values other
than 1, unless the element is an SVG element without an associated CSS layout
box."

So
will-change: offset-path
should be treated the same as
will-change: opacity

             return true;
         default:
             break;
         }
     }
     return false;
 }
 
 void ComputedStyle::updateIsStackingContext(bool isDocumentElement, bool isInTopLayer)
 {
@@ skipping 89 matching lines @@
     return scale() || rotate();
 }
 
 void ComputedStyle::applyTransform(TransformationMatrix& result, const LayoutSize& borderBoxSize, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyIndependentTransformProperties applyIndependentTransformProperties) const
 {
     applyTransform(result, FloatRect(FloatPoint(), FloatSize(borderBoxSize)), applyOrigin, applyMotionPath, applyIndependentTransformProperties);
 }
 
 void ComputedStyle::applyTransform(TransformationMatrix& result, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyIndependentTransformProperties applyIndependentTransformProperties) const
 {
-    if (!hasMotionPath())
+    if (!hasOffsetPath())
         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;
 
@@ skipping 27 matching lines @@
         result.translate3d(-originX, -originY, -originZ);
     }
 }
 
 void ComputedStyle::applyMotionPathTransform(float originX, float originY, TransformationMatrix& transform) const
 {
     const StyleMotionData& motionData = m_rareNonInheritedData->m_transform->m_motion;
     ASSERT(motionData.m_path);
     const StylePath& motionPath = *motionData.m_path;
     float pathLength = motionPath.length();
-    float distance = floatValueForLength(motionData.m_offset, pathLength);
+    float distance = floatValueForLength(motionData.m_distance, 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;
     motionPath.path().pointAndNormalAtLength(computedDistance, point, angle);
 
-    if (motionData.m_rotation.type == MotionRotationFixed)
+    if (motionData.m_rotation.type == OffsetRotationFixed)
         angle = 0;
 
     transform.translate(point.x() - originX, point.y() - originY);
     transform.rotate(angle + motionData.m_rotation.angle);
 }
 
 void ComputedStyle::setTextShadow(PassRefPtr<ShadowList> s)
 {
     m_rareInheritedData.access()->textShadow = s;
 }
@@ skipping 675 matching lines @@
         else
             setMarginLeft(margin);
     } else {
         if (isLeftToRightDirection())
             setMarginBottom(margin);
         else
             setMarginTop(margin);
     }
 }
 
-void ComputedStyle::setMotionPath(PassRefPtr<StylePath> path)
+void ComputedStyle::setOffsetPath(PassRefPtr<StylePath> path)
 {
     m_rareNonInheritedData.access()->m_transform.access()->m_motion.m_path = path;
 }
 
 int ComputedStyle::outlineOutsetExtent() const
 {
     if (!hasOutline())
         return 0;
     if (outlineStyleIsAuto())
         return GraphicsContext::focusRingOutsetExtent(outlineOffset(), outlineWidth());
@@ skipping 172 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink