Unify animate motion transform update invalidations

third_party/WebKit/Source/core/svg/SVGAnimateMotionElement.cpp

 /*
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. 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 146 matching lines @@
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return;
 
   AffineTransform* transform = targetElement->animateMotionTransform();
   if (!transform)
     return;
 
   transform->makeIdentity();
 
-  if (LayoutObject* targetLayoutObject = targetElement->layoutObject()) {
-    targetLayoutObject->setNeedsTransformUpdate();
-    markForLayoutAndParentResourceInvalidation(targetLayoutObject);
-  }
+  if (LayoutObject* targetLayoutObject = targetElement->layoutObject())
+    invalidateForAnimateMotionTransformChange(*targetLayoutObject);
 }
 
 bool SVGAnimateMotionElement::calculateToAtEndOfDurationValue(
     const String& toAtEndOfDurationString) {
   parsePoint(toAtEndOfDurationString, m_toPointAtEndOfDuration);
   m_hasToPointAtEndOfDuration = true;
   return true;
 }
 
 bool SVGAnimateMotionElement::calculateFromAndToValues(const String& fromString,
@@ skipping 20 matching lines @@
 void SVGAnimateMotionElement::calculateAnimatedValue(float percentage,
                                                      unsigned repeatCount,
                                                      SVGSMILElement*) {
   SVGElement* targetElement = this->targetElement();
   DCHECK(targetElement);
   AffineTransform* transform = targetElement->animateMotionTransform();
   if (!transform)
     return;
 
   if (LayoutObject* targetLayoutObject = targetElement->layoutObject())
-    targetLayoutObject->setNeedsTransformUpdate();
+    invalidateForAnimateMotionTransformChange(*targetLayoutObject);
 
   if (!isAdditive())
     transform->makeIdentity();
 
   if (getAnimationMode() != PathAnimation) {
     FloatPoint toPointAtEndOfDuration = m_toPoint;
     if (isAccumulated() && repeatCount && m_hasToPointAtEndOfDuration)
       toPointAtEndOfDuration = m_toPointAtEndOfDuration;
 
     float animatedX = 0;
@@ skipping 32 matching lines @@
   transform->rotate(angle);
 }
 
 void SVGAnimateMotionElement::applyResultsToTarget() {
   // We accumulate to the target element transform list so there is not much to
   // do here.
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return;
 
-  if (LayoutObject* layoutObject = targetElement->layoutObject())
-    markForLayoutAndParentResourceInvalidation(layoutObject);
-
   AffineTransform* t = targetElement->animateMotionTransform();
   if (!t)
     return;
 
   // ...except in case where we have additional instances in <use> trees.
   const HeapHashSet<WeakMember<SVGElement>>& instances =
       targetElement->instancesForElement();
   for (SVGElement* shadowTreeElement : instances) {
     ASSERT(shadowTreeElement);
     AffineTransform* transform = shadowTreeElement->animateMotionTransform();
     if (!transform)
       continue;
     transform->setMatrix(t->a(), t->b(), t->c(), t->d(), t->e(), t->f());
-    if (LayoutObject* layoutObject = shadowTreeElement->layoutObject()) {
-      layoutObject->setNeedsTransformUpdate();
-      markForLayoutAndParentResourceInvalidation(layoutObject);
-    }
+    if (LayoutObject* layoutObject = shadowTreeElement->layoutObject())
+      invalidateForAnimateMotionTransformChange(*layoutObject);
   }
 }
 
 float SVGAnimateMotionElement::calculateDistance(const String& fromString,
                                                  const String& toString) {
   FloatPoint from;
   FloatPoint to;
   if (!parsePoint(fromString, from))
     return -1;
   if (!parsePoint(toString, to))
     return -1;
   FloatSize diff = to - from;
   return sqrtf(diff.width() * diff.width() + diff.height() * diff.height());
 }
 
 void SVGAnimateMotionElement::updateAnimationMode() {
   if (!m_animationPath.isEmpty())
     setAnimationMode(PathAnimation);
   else
     SVGAnimationElement::updateAnimationMode();
 }
 
+void SVGAnimateMotionElement::invalidateForAnimateMotionTransformChange(
+    LayoutObject& object) {
+  object.setNeedsTransformUpdate();
+  markForLayoutAndParentResourceInvalidation(&object);
+}
+
 }  // namespace blink