Make 'transform' a presentation attribute on SVG elements

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann
  * <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/svg/SVGPatternElement.h"
 
 #include "core/dom/ElementTraversal.h"
+#include "core/dom/StyleChangeReason.h"
 #include "core/layout/svg/LayoutSVGResourcePattern.h"
 #include "core/svg/PatternAttributes.h"
 #include "platform/transforms/AffineTransform.h"
 
 namespace blink {
 
 inline SVGPatternElement::SVGPatternElement(Document& document)
     : SVGElement(SVGNames::patternTag, document),
       SVGURIReference(this),
       SVGTests(this),
       SVGFitToViewBox(this),
       m_x(SVGAnimatedLength::create(this,
                                     SVGNames::xAttr,
                                     SVGLength::create(SVGLengthMode::Width))),
       m_y(SVGAnimatedLength::create(this,
                                     SVGNames::yAttr,
                                     SVGLength::create(SVGLengthMode::Height))),
       m_width(
           SVGAnimatedLength::create(this,
                                     SVGNames::widthAttr,
                                     SVGLength::create(SVGLengthMode::Width))),
       m_height(
           SVGAnimatedLength::create(this,
                                     SVGNames::heightAttr,
                                     SVGLength::create(SVGLengthMode::Height))),
       m_patternTransform(
           SVGAnimatedTransformList::create(this,
-                                           SVGNames::patternTransformAttr)),
+                                           SVGNames::patternTransformAttr,
+                                           CSSPropertyTransform)),
       m_patternUnits(SVGAnimatedEnumeration<SVGUnitTypes::SVGUnitType>::create(
           this,
           SVGNames::patternUnitsAttr,
           SVGUnitTypes::kSvgUnitTypeObjectboundingbox)),
       m_patternContentUnits(
           SVGAnimatedEnumeration<SVGUnitTypes::SVGUnitType>::create(
               this,
               SVGNames::patternContentUnitsAttr,
               SVGUnitTypes::kSvgUnitTypeUserspaceonuse)) {
   addToPropertyMap(m_x);
@@ skipping 14 matching lines @@
   visitor->trace(m_patternUnits);
   visitor->trace(m_patternContentUnits);
   SVGElement::trace(visitor);
   SVGURIReference::trace(visitor);
   SVGTests::trace(visitor);
   SVGFitToViewBox::trace(visitor);
 }
 
 DEFINE_NODE_FACTORY(SVGPatternElement)
 
+void SVGPatternElement::collectStyleForPresentationAttribute(
+    const QualifiedName& name,
+    const AtomicString& value,
+    MutableStylePropertySet* style) {
+  if (name == SVGNames::patternTransformAttr) {
+    addPropertyToPresentationAttributeStyle(
+        style, CSSPropertyTransform,
+        m_patternTransform->currentValue()->cssValue());
+    return;
+  }
+  SVGElement::collectStyleForPresentationAttribute(name, value, style);
+}
+
 void SVGPatternElement::svgAttributeChanged(const QualifiedName& attrName) {
   bool isLengthAttr =
       attrName == SVGNames::xAttr || attrName == SVGNames::yAttr ||
       attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
 
+  if (attrName == SVGNames::patternTransformAttr) {
+    invalidateSVGPresentationAttributeStyle();
+    setNeedsStyleRecalc(LocalStyleChange,
+                        StyleChangeReasonForTracing::fromAttribute(attrName));
+  }
+
   if (isLengthAttr || attrName == SVGNames::patternUnitsAttr ||
       attrName == SVGNames::patternContentUnitsAttr ||
       attrName == SVGNames::patternTransformAttr ||
       SVGFitToViewBox::isKnownAttribute(attrName) ||
       SVGURIReference::isKnownAttribute(attrName) ||
       SVGTests::isKnownAttribute(attrName)) {
     SVGElement::InvalidationGuard invalidationGuard(this);
 
     if (isLengthAttr)
       updateRelativeLengthsInformation();
@@ skipping 50 matching lines @@
   if (!attributes.hasPatternUnits() && element->patternUnits()->isSpecified())
     attributes.setPatternUnits(
         element->patternUnits()->currentValue()->enumValue());
 
   if (!attributes.hasPatternContentUnits() &&
       element->patternContentUnits()->isSpecified())
     attributes.setPatternContentUnits(
         element->patternContentUnits()->currentValue()->enumValue());
 
   if (!attributes.hasPatternTransform() &&
-      element->patternTransform()->isSpecified()) {
-    AffineTransform transform;
-    element->patternTransform()->currentValue()->concatenate(transform);
-    attributes.setPatternTransform(transform);
+      element->hasTransform(SVGElement::ExcludeMotionTransform)) {
+    attributes.setPatternTransform(
+        element->calculateTransform(SVGElement::ExcludeMotionTransform));
   }
 
   if (!attributes.hasPatternContentElement() &&
       ElementTraversal::firstWithin(*element))
     attributes.setPatternContentElement(element);
 }
 
 void SVGPatternElement::collectPatternAttributes(
     PatternAttributes& attributes) const {
   HeapHashSet<Member<const SVGPatternElement>> processedPatterns;
@@ skipping 14 matching lines @@
     current = toSVGPatternElement(refNode);
 
     // Cycle detection
     if (processedPatterns.contains(current))
       break;
   }
 }
 
 AffineTransform SVGPatternElement::localCoordinateSpaceTransform(
     SVGElement::CTMScope) const {
-  AffineTransform matrix;
-  m_patternTransform->currentValue()->concatenate(matrix);
-  return matrix;
+  return calculateTransform(SVGElement::ExcludeMotionTransform);
 }
 
 bool SVGPatternElement::selfHasRelativeLengths() const {
   return m_x->currentValue()->isRelative() ||
          m_y->currentValue()->isRelative() ||
          m_width->currentValue()->isRelative() ||
          m_height->currentValue()->isRelative();
 }
 
 }  // namespace blink