Use ASCII-caseless matching for attribute names.

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 375 matching lines @@
     ToSVGElement(this)->SynchronizeAnimatedSVGAttribute(name);
   }
 }
 
 void Element::SynchronizeAttribute(const AtomicString& local_name) const {
   // This version of synchronizeAttribute() is streamlined for the case where
   // you don't have a full QualifiedName, e.g when called from DOM API.
   if (!GetElementData())
     return;
   if (GetElementData()->style_attribute_is_dirty_ &&
-      EqualPossiblyIgnoringCase(local_name, styleAttr.LocalName(),
-                                ShouldIgnoreAttributeCase())) {
+      EqualPossiblyIgnoringASCIICase(local_name, styleAttr.LocalName(),
+                                     ShouldIgnoreAttributeCase())) {
     DCHECK(IsStyledElement());
     SynchronizeStyleAttributeInternal();
     return;
   }
   if (GetElementData()->animated_svg_attributes_are_dirty_) {
     // We're not passing a namespace argument on purpose. SVGNames::*Attr are
     // defined w/o namespaces as well.
 
     // FIXME: this code is called regardless of whether name is an
     // animated SVG Attribute. It would seem we should only call this method
@@ skipping 828 matching lines @@
                            ExceptionState& exception_state) {
   if (!Document::IsValidName(local_name)) {
     exception_state.ThrowDOMException(
         kInvalidCharacterError,
         "'" + local_name + "' is not a valid attribute name.");
     return;
   }
 
   SynchronizeAttribute(local_name);
   const AtomicString& case_adjusted_local_name =
-      ShouldIgnoreAttributeCase() ? local_name.DeprecatedLower() : local_name;
+      ShouldIgnoreAttributeCase() ? local_name.LowerASCII() : local_name;
 
   if (!GetElementData()) {
     SetAttributeInternal(
         kNotFound,
         QualifiedName(g_null_atom, case_adjusted_local_name, g_null_atom),
         value, kNotInSynchronizationOfLazyAttribute);
     return;
   }
 
   AttributeCollection attributes = GetElementData()->Attributes();
@@ skipping 1199 matching lines @@
   // to re-use them in other elements.
   if (attr_node->ownerElement()) {
     exception_state.ThrowDOMException(
         kInUseAttributeError,
         "The node provided is an attribute node that is already an attribute "
         "of another Element; attribute nodes must be explicitly cloned.");
     return nullptr;
   }
 
   if (!IsHTMLElement() && attr_node->GetDocument().IsHTMLDocument() &&
-      attr_node->name() != attr_node->name().DeprecatedLower())
+      attr_node->name() != attr_node->name().LowerASCII())
     UseCounter::Count(
         GetDocument(),
         UseCounter::
             kNonHTMLElementSetAttributeNodeFromHTMLDocumentNameNotLowercase);
 
   SynchronizeAllAttributes();
   const UniqueElementData& element_data = EnsureUniqueElementData();
 
   AttributeCollection attributes = element_data.Attributes();
   size_t index = attributes.FindIndex(attr_node->GetQualifiedName(),
@@ skipping 146 matching lines @@
   EnsureUniqueElementData().Attributes().Append(name, value);
   if (!in_synchronization_of_lazy_attribute)
     DidAddAttribute(name, value);
 }
 
 void Element::removeAttribute(const AtomicString& name) {
   if (!GetElementData())
     return;
 
   AtomicString local_name =
-      ShouldIgnoreAttributeCase() ? name.DeprecatedLower() : name;
+      ShouldIgnoreAttributeCase() ? name.LowerASCII() : name;
   size_t index = GetElementData()->Attributes().FindIndex(local_name, false);
   if (index == kNotFound) {
     if (UNLIKELY(local_name == styleAttr) &&
         GetElementData()->style_attribute_is_dirty_ && IsStyledElement())
       RemoveAllInlineStyleProperties();
     return;
   }
 
   RemoveAttributeInternal(index, kNotInSynchronizationOfLazyAttribute);
 }
@@ skipping 24 matching lines @@
   if (!attribute)
     return nullptr;
   return EnsureAttr(attribute->GetName());
 }
 
 bool Element::hasAttribute(const AtomicString& local_name) const {
   if (!GetElementData())
     return false;
   SynchronizeAttribute(local_name);
   return GetElementData()->Attributes().FindIndex(
-             ShouldIgnoreAttributeCase() ? local_name.DeprecatedLower()
-                                         : local_name,
+             ShouldIgnoreAttributeCase() ? local_name.LowerASCII() : local_name,
              false) != kNotFound;
 }
 
 bool Element::hasAttributeNS(const AtomicString& namespace_uri,
                              const AtomicString& local_name) const {
   if (!GetElementData())
     return false;
   QualifiedName q_name(g_null_atom, local_name, namespace_uri);
   SynchronizeAttribute(q_name);
   return GetElementData()->Attributes().Find(q_name);
@@ skipping 1191 matching lines @@
 void Element::SetSavedLayerScrollOffset(const ScrollOffset& size) {
   if (size.IsZero() && !HasRareData())
     return;
   EnsureElementRareData().SetSavedLayerScrollOffset(size);
 }
 
 Attr* Element::AttrIfExists(const QualifiedName& name) {
   if (AttrNodeList* attr_node_list = this->GetAttrNodeList()) {
     bool should_ignore_case = ShouldIgnoreAttributeCase();
     for (const auto& attr : *attr_node_list) {
-      if (attr->GetQualifiedName().MatchesPossiblyIgnoringCase(
+      if (attr->GetQualifiedName().MatchesPossiblyIgnoringASCIICase(
               name, should_ignore_case))
         return attr.Get();
     }
   }
   return nullptr;
 }
 
 Attr* Element::EnsureAttr(const QualifiedName& name) {
   Attr* attr_node = AttrIfExists(name);
   if (!attr_node) {
@@ skipping 441 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (HasRareData()) {
     visitor->TraceWrappers(GetElementRareData());
   }
   ContainerNode::TraceWrappers(visitor);
 }
 
 }  // namespace blink