Literal AtomicString construction can rely on strlen optimization.

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

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  * 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
@@ skipping 283 matching lines @@
     else if (!toValue().isEmpty())
         setAnimationMode(fromValue().isEmpty() ? ToAnimation : FromToAnimation);
     else if (!byValue().isEmpty())
         setAnimationMode(fromValue().isEmpty() ? ByAnimation : FromByAnimation);
     else
         setAnimationMode(NoAnimation);
 }
 
 void SVGAnimationElement::setCalcMode(const AtomicString& calcMode)
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, discrete, ("discrete", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, linear, ("linear", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, paced, ("paced", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, spline, ("spline", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, discrete, ("discrete"));
+    DEFINE_STATIC_LOCAL(const AtomicString, linear, ("linear"));
+    DEFINE_STATIC_LOCAL(const AtomicString, paced, ("paced"));
+    DEFINE_STATIC_LOCAL(const AtomicString, spline, ("spline"));
     if (calcMode == discrete)
         setCalcMode(CalcModeDiscrete);
     else if (calcMode == linear)
         setCalcMode(CalcModeLinear);
     else if (calcMode == paced)
         setCalcMode(CalcModePaced);
     else if (calcMode == spline)
         setCalcMode(CalcModeSpline);
     else
         setCalcMode(isSVGAnimateMotionElement(*this) ? CalcModePaced : CalcModeLinear);
 }
 
 void SVGAnimationElement::setAttributeType(const AtomicString& attributeType)
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, css, ("CSS", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, xml, ("XML", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, css, ("CSS"));
+    DEFINE_STATIC_LOCAL(const AtomicString, xml, ("XML"));
     if (attributeType == css)
         m_attributeType = AttributeTypeCSS;
     else if (attributeType == xml)
         m_attributeType = AttributeTypeXML;
     else
         m_attributeType = AttributeTypeAuto;
     checkInvalidCSSAttributeType();
 }
 
 String SVGAnimationElement::toValue() const
 {
     return fastGetAttribute(SVGNames::toAttr);
 }
 
 String SVGAnimationElement::byValue() const
 {
     return fastGetAttribute(SVGNames::byAttr);
 }
 
 String SVGAnimationElement::fromValue() const
 {
     return fastGetAttribute(SVGNames::fromAttr);
 }
 
 bool SVGAnimationElement::isAdditive()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum"));
     const AtomicString& value = fastGetAttribute(SVGNames::additiveAttr);
     return value == sum || getAnimationMode() == ByAnimation;
 }
 
 bool SVGAnimationElement::isAccumulated() const
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum"));
     const AtomicString& value = fastGetAttribute(SVGNames::accumulateAttr);
     return value == sum && getAnimationMode() != ToAnimation;
 }
 
 bool SVGAnimationElement::isTargetAttributeCSSProperty(SVGElement* targetElement, const QualifiedName& attributeName)
 {
     ASSERT(targetElement);
 
     return SVGElement::isAnimatableCSSProperty(attributeName) || targetElement->isPresentationAttribute(attributeName);
 }
@@ skipping 305 matching lines @@
     if (!parent || !parent->isSVGElement())
         return;
 
     SVGElement* svgParent = toSVGElement(parent);
     computeCSSPropertyValue(svgParent, cssPropertyID(attributeName.localName()), value);
 }
 
 static bool inheritsFromProperty(SVGElement* targetElement, const QualifiedName& attributeName, const String& value)
 {
     ASSERT(targetElement);
-    DEFINE_STATIC_LOCAL(const AtomicString, inherit, ("inherit", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, inherit, ("inherit"));
 
     if (value.isEmpty() || value != inherit)
         return false;
     return SVGElement::isAnimatableCSSProperty(attributeName);
 }
 
 void SVGAnimationElement::determinePropertyValueTypes(const String& from, const String& to)
 {
     SVGElement* targetElement = this->targetElement();
     ASSERT(targetElement);
@@ skipping 30 matching lines @@
         if (!hasInvalidCSSAttributeType)
             schedule();
     }
 
     // Clear values that may depend on the previous target.
     if (targetElement())
         clearAnimatedType();
 }
 
 } // namespace blink