Rename EqualIgnoringCase*() to DeprecatedEqualIgnoringCase*()

third_party/WebKit/Source/core/html/HTMLElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004-2008, 2013, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2011 Motorola Mobility. 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 187 matching lines @@
     size_t first_separator = html_language.Find('-');
     if (first_separator != kNotFound)
       html_language = html_language.Left(first_separator);
     String ui_language = DefaultLanguage();
     first_separator = ui_language.Find('-');
     if (first_separator != kNotFound)
       ui_language = ui_language.Left(first_separator);
     first_separator = ui_language.Find('_');
     if (first_separator != kNotFound)
       ui_language = ui_language.Left(first_separator);
-    if (!EqualIgnoringCase(html_language, ui_language))
+    if (!DeprecatedEqualIgnoringCase(html_language, ui_language))
       UseCounter::Count(GetDocument(),
                         UseCounter::kLangAttributeDoesNotMatchToUILocale);
   } else {
     // The empty string means the language is explicitly unknown.
     AddPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLocale,
                                             CSSValueAuto);
   }
 }
 
 bool HTMLElement::IsPresentationAttribute(const QualifiedName& name) const {
   if (name == alignAttr || name == contenteditableAttr || name == hiddenAttr ||
       name == langAttr || name.Matches(XMLNames::langAttr) ||
       name == draggableAttr || name == dirAttr)
     return true;
   return Element::IsPresentationAttribute(name);
 }
 
 static inline bool IsValidDirAttribute(const AtomicString& value) {
-  return EqualIgnoringCase(value, "auto") || EqualIgnoringCase(value, "ltr") ||
-         EqualIgnoringCase(value, "rtl");
+  return DeprecatedEqualIgnoringCase(value, "auto") ||
+         DeprecatedEqualIgnoringCase(value, "ltr") ||
+         DeprecatedEqualIgnoringCase(value, "rtl");
 }
 
 void HTMLElement::CollectStyleForPresentationAttribute(
     const QualifiedName& name,
     const AtomicString& value,
     MutableStylePropertySet* style) {
   if (name == alignAttr) {
-    if (EqualIgnoringCase(value, "middle"))
+    if (DeprecatedEqualIgnoringCase(value, "middle"))
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign,
                                               CSSValueCenter);
     else
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign,
                                               value);
   } else if (name == contenteditableAttr) {
-    if (value.IsEmpty() || EqualIgnoringCase(value, "true")) {
+    if (value.IsEmpty() || DeprecatedEqualIgnoringCase(value, "true")) {
       AddPropertyToPresentationAttributeStyle(
           style, CSSPropertyWebkitUserModify, CSSValueReadWrite);
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap,
                                               CSSValueBreakWord);
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak,
                                               CSSValueAfterWhiteSpace);
       UseCounter::Count(GetDocument(), UseCounter::kContentEditableTrue);
       if (HasTagName(htmlTag))
         UseCounter::Count(GetDocument(),
                           UseCounter::kContentEditableTrueOnHTML);
-    } else if (EqualIgnoringCase(value, "plaintext-only")) {
+    } else if (DeprecatedEqualIgnoringCase(value, "plaintext-only")) {
       AddPropertyToPresentationAttributeStyle(
           style, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap,
                                               CSSValueBreakWord);
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak,
                                               CSSValueAfterWhiteSpace);
       UseCounter::Count(GetDocument(),
                         UseCounter::kContentEditablePlainTextOnly);
-    } else if (EqualIgnoringCase(value, "false")) {
+    } else if (DeprecatedEqualIgnoringCase(value, "false")) {
       AddPropertyToPresentationAttributeStyle(
           style, CSSPropertyWebkitUserModify, CSSValueReadOnly);
     }
   } else if (name == hiddenAttr) {
     AddPropertyToPresentationAttributeStyle(style, CSSPropertyDisplay,
                                             CSSValueNone);
   } else if (name == draggableAttr) {
     UseCounter::Count(GetDocument(), UseCounter::kDraggableAttribute);
-    if (EqualIgnoringCase(value, "true")) {
+    if (DeprecatedEqualIgnoringCase(value, "true")) {
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag,
                                               CSSValueElement);
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyUserSelect,
                                               CSSValueNone);
-    } else if (EqualIgnoringCase(value, "false")) {
+    } else if (DeprecatedEqualIgnoringCase(value, "false")) {
       AddPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag,
                                               CSSValueNone);
     }
   } else if (name == dirAttr) {
-    if (EqualIgnoringCase(value, "auto")) {
+    if (DeprecatedEqualIgnoringCase(value, "auto")) {
       AddPropertyToPresentationAttributeStyle(
           style, CSSPropertyUnicodeBidi, UnicodeBidiAttributeForDirAuto(this));
     } else {
       if (IsValidDirAttribute(value))
         AddPropertyToPresentationAttributeStyle(style, CSSPropertyDirection,
                                                 value);
       else if (isHTMLBodyElement(*this))
         AddPropertyToPresentationAttributeStyle(style, CSSPropertyDirection,
                                                 "ltr");
       if (!HasTagName(bdiTag) && !HasTagName(bdoTag) && !HasTagName(outputTag))
@@ skipping 291 matching lines @@
 }
 
 void HTMLElement::ApplyAlignmentAttributeToStyle(
     const AtomicString& alignment,
     MutableStylePropertySet* style) {
   // Vertical alignment with respect to the current baseline of the text
   // right or left means floating images.
   CSSValueID float_value = CSSValueInvalid;
   CSSValueID vertical_align_value = CSSValueInvalid;
 
-  if (EqualIgnoringCase(alignment, "absmiddle")) {
+  if (DeprecatedEqualIgnoringCase(alignment, "absmiddle")) {
     vertical_align_value = CSSValueMiddle;
-  } else if (EqualIgnoringCase(alignment, "absbottom")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "absbottom")) {
     vertical_align_value = CSSValueBottom;
-  } else if (EqualIgnoringCase(alignment, "left")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "left")) {
     float_value = CSSValueLeft;
     vertical_align_value = CSSValueTop;
-  } else if (EqualIgnoringCase(alignment, "right")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "right")) {
     float_value = CSSValueRight;
     vertical_align_value = CSSValueTop;
-  } else if (EqualIgnoringCase(alignment, "top")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "top")) {
     vertical_align_value = CSSValueTop;
-  } else if (EqualIgnoringCase(alignment, "middle")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "middle")) {
     vertical_align_value = CSSValueWebkitBaselineMiddle;
-  } else if (EqualIgnoringCase(alignment, "center")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "center")) {
     vertical_align_value = CSSValueMiddle;
-  } else if (EqualIgnoringCase(alignment, "bottom")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "bottom")) {
     vertical_align_value = CSSValueBaseline;
-  } else if (EqualIgnoringCase(alignment, "texttop")) {
+  } else if (DeprecatedEqualIgnoringCase(alignment, "texttop")) {
     vertical_align_value = CSSValueTextTop;
   }
 
   if (float_value != CSSValueInvalid)
     AddPropertyToPresentationAttributeStyle(style, CSSPropertyFloat,
                                             float_value);
 
   if (vertical_align_value != CSSValueInvalid)
     AddPropertyToPresentationAttributeStyle(style, CSSPropertyVerticalAlign,
                                             vertical_align_value);
 }
 
 bool HTMLElement::HasCustomFocusLogic() const {
   return false;
 }
 
 String HTMLElement::contentEditable() const {
   const AtomicString& value = FastGetAttribute(contenteditableAttr);
 
   if (value.IsNull())
     return "inherit";
-  if (value.IsEmpty() || EqualIgnoringCase(value, "true"))
+  if (value.IsEmpty() || DeprecatedEqualIgnoringCase(value, "true"))
     return "true";
-  if (EqualIgnoringCase(value, "false"))
+  if (DeprecatedEqualIgnoringCase(value, "false"))
     return "false";
-  if (EqualIgnoringCase(value, "plaintext-only"))
+  if (DeprecatedEqualIgnoringCase(value, "plaintext-only"))
     return "plaintext-only";
 
   return "inherit";
 }
 
 void HTMLElement::setContentEditable(const String& enabled,
                                      ExceptionState& exception_state) {
-  if (EqualIgnoringCase(enabled, "true"))
+  if (DeprecatedEqualIgnoringCase(enabled, "true"))
     setAttribute(contenteditableAttr, "true");
-  else if (EqualIgnoringCase(enabled, "false"))
+  else if (DeprecatedEqualIgnoringCase(enabled, "false"))
     setAttribute(contenteditableAttr, "false");
-  else if (EqualIgnoringCase(enabled, "plaintext-only"))
+  else if (DeprecatedEqualIgnoringCase(enabled, "plaintext-only"))
     setAttribute(contenteditableAttr, "plaintext-only");
-  else if (EqualIgnoringCase(enabled, "inherit"))
+  else if (DeprecatedEqualIgnoringCase(enabled, "inherit"))
     removeAttribute(contenteditableAttr);
   else
     exception_state.ThrowDOMException(kSyntaxError,
                                       "The value provided ('" + enabled +
                                           "') is not one of 'true', 'false', "
                                           "'plaintext-only', or 'inherit'.");
 }
 
 bool HTMLElement::isContentEditableForBinding() const {
   return IsEditingHost(*this) || IsEditable(*this);
 }
 
 bool HTMLElement::draggable() const {
-  return EqualIgnoringCase(getAttribute(draggableAttr), "true");
+  return DeprecatedEqualIgnoringCase(getAttribute(draggableAttr), "true");
 }
 
 void HTMLElement::setDraggable(bool value) {
   setAttribute(draggableAttr, value ? "true" : "false");
 }
 
 bool HTMLElement::spellcheck() const {
   return IsSpellCheckingEnabled();
 }
 
@@ skipping 19 matching lines @@
   if (SupportsFocus())
     return Element::tabIndex();
   return -1;
 }
 
 TranslateAttributeMode HTMLElement::GetTranslateAttributeMode() const {
   const AtomicString& value = getAttribute(translateAttr);
 
   if (value == g_null_atom)
     return kTranslateAttributeInherit;
-  if (EqualIgnoringCase(value, "yes") || EqualIgnoringCase(value, ""))
+  if (DeprecatedEqualIgnoringCase(value, "yes") ||
+      DeprecatedEqualIgnoringCase(value, ""))
     return kTranslateAttributeYes;
-  if (EqualIgnoringCase(value, "no"))
+  if (DeprecatedEqualIgnoringCase(value, "no"))
     return kTranslateAttributeNo;
 
   return kTranslateAttributeInherit;
 }
 
 bool HTMLElement::translate() const {
   for (const HTMLElement* element = this; element;
        element = Traversal<HTMLElement>::FirstAncestor(*element)) {
     TranslateAttributeMode mode = element->GetTranslateAttributeMode();
     if (mode != kTranslateAttributeInherit) {
@@ skipping 14 matching lines @@
 // in (in its canonical case), if any, or the empty string if the attribute is
 // in a state that has no associated keyword value or if the attribute is not in
 // a defined state (e.g. the attribute is missing and there is no missing value
 // default).
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#limited-to-only-known-values
 static inline const AtomicString& ToValidDirValue(const AtomicString& value) {
   DEFINE_STATIC_LOCAL(const AtomicString, ltr_value, ("ltr"));
   DEFINE_STATIC_LOCAL(const AtomicString, rtl_value, ("rtl"));
   DEFINE_STATIC_LOCAL(const AtomicString, auto_value, ("auto"));
 
-  if (EqualIgnoringCase(value, ltr_value))
+  if (DeprecatedEqualIgnoringCase(value, ltr_value))
     return ltr_value;
-  if (EqualIgnoringCase(value, rtl_value))
+  if (DeprecatedEqualIgnoringCase(value, rtl_value))
     return rtl_value;
-  if (EqualIgnoringCase(value, auto_value))
+  if (DeprecatedEqualIgnoringCase(value, auto_value))
     return auto_value;
   return g_null_atom;
 }
 
 const AtomicString& HTMLElement::dir() {
   return ToValidDirValue(FastGetAttribute(dirAttr));
 }
 
 void HTMLElement::setDir(const AtomicString& value) {
   setAttribute(dirAttr, value);
@@ skipping 11 matching lines @@
 void HTMLElement::ChildrenChanged(const ChildrenChange& change) {
   Element::ChildrenChanged(change);
   AdjustDirectionalityIfNeededAfterChildrenChanged(change);
 }
 
 bool HTMLElement::HasDirectionAuto() const {
   // <bdi> defaults to dir="auto"
   // https://html.spec.whatwg.org/multipage/semantics.html#the-bdi-element
   const AtomicString& direction = FastGetAttribute(dirAttr);
   return (isHTMLBDIElement(*this) && direction == g_null_atom) ||
-         EqualIgnoringCase(direction, "auto");
+         DeprecatedEqualIgnoringCase(direction, "auto");
 }
 
 TextDirection HTMLElement::DirectionalityIfhasDirAutoAttribute(
     bool& is_auto) const {
   is_auto = HasDirectionAuto();
   if (!is_auto)
     return TextDirection::kLtr;
   return Directionality();
 }
 
 TextDirection HTMLElement::Directionality(
     Node** strong_directionality_text_node) const {
   if (isHTMLInputElement(*this)) {
     HTMLInputElement* input_element =
         toHTMLInputElement(const_cast<HTMLElement*>(this));
     bool has_strong_directionality;
     TextDirection text_direction = DetermineDirectionality(
         input_element->value(), &has_strong_directionality);
     if (strong_directionality_text_node)
       *strong_directionality_text_node =
           has_strong_directionality ? input_element : 0;
     return text_direction;
   }
 
   Node* node = FlatTreeTraversal::FirstChild(*this);
   while (node) {
     // Skip bdi, script, style and text form controls.
-    if (EqualIgnoringCase(node->nodeName(), "bdi") ||
+    if (DeprecatedEqualIgnoringCase(node->nodeName(), "bdi") ||
         isHTMLScriptElement(*node) || isHTMLStyleElement(*node) ||
         (node->IsElementNode() && ToElement(node)->IsTextControl()) ||
         (node->IsElementNode() &&
          ToElement(node)->ShadowPseudoId() == "-webkit-input-placeholder")) {
       node = FlatTreeTraversal::NextSkippingChildren(*node, this);
       continue;
     }
 
     // Skip elements with valid dir attribute
     if (node->IsElementNode()) {
@@ skipping 36 matching lines @@
   // changes to dir attribute may affect the ancestor.
   if (!CanParticipateInFlatTree())
     return;
   UpdateDistribution();
   Element* parent = FlatTreeTraversal::ParentElement(*this);
   if (parent && parent->IsHTMLElement() &&
       ToHTMLElement(parent)->SelfOrAncestorHasDirAutoAttribute())
     ToHTMLElement(parent)
         ->AdjustDirectionalityIfNeededAfterChildAttributeChanged(this);
 
-  if (EqualIgnoringCase(value, "auto"))
+  if (DeprecatedEqualIgnoringCase(value, "auto"))
     CalculateAndAdjustDirectionality();
 }
 
 void HTMLElement::AdjustDirectionalityIfNeededAfterChildAttributeChanged(
     Element* child) {
   DCHECK(SelfOrAncestorHasDirAutoAttribute());
   const ComputedStyle* style = GetComputedStyle();
   if (style && style->Direction() != Directionality()) {
     for (Element* element_to_adjust = this; element_to_adjust;
          element_to_adjust =
@@ skipping 127 matching lines @@
 bool HTMLElement::ParseColorWithLegacyRules(const String& attribute_value,
                                             Color& parsed_color) {
   // An empty string doesn't apply a color. (One containing only whitespace
   // does, which is why this check occurs before stripping.)
   if (attribute_value.IsEmpty())
     return false;
 
   String color_string = attribute_value.StripWhiteSpace();
 
   // "transparent" doesn't apply a color either.
-  if (EqualIgnoringCase(color_string, "transparent"))
+  if (DeprecatedEqualIgnoringCase(color_string, "transparent"))
     return false;
 
   // If the string is a 3/6-digit hex color or a named CSS color, use that.
   // Apply legacy rules otherwise. Note color.setFromString() accepts 4/8-digit
   // hex color, so restrict its use with length checks here to support legacy
   // HTML attributes.
 
   bool success = false;
   if ((color_string.length() == 4 || color_string.length() == 7) &&
       color_string[0] == '#')
@@ skipping 76 matching lines @@
 }
 
 bool HTMLElement::MatchesReadOnlyPseudoClass() const {
   return !MatchesReadWritePseudoClass();
 }
 
 bool HTMLElement::MatchesReadWritePseudoClass() const {
   if (FastHasAttribute(contenteditableAttr)) {
     const AtomicString& value = FastGetAttribute(contenteditableAttr);
 
-    if (value.IsEmpty() || EqualIgnoringCase(value, "true") ||
-        EqualIgnoringCase(value, "plaintext-only"))
+    if (value.IsEmpty() || DeprecatedEqualIgnoringCase(value, "true") ||
+        DeprecatedEqualIgnoringCase(value, "plaintext-only"))
       return true;
-    if (EqualIgnoringCase(value, "false"))
+    if (DeprecatedEqualIgnoringCase(value, "false"))
       return false;
     // All other values should be treated as "inherit".
   }
 
   return parentElement() && HasEditableStyle(*parentElement());
 }
 
 void HTMLElement::HandleKeypressEvent(KeyboardEvent* event) {
   if (!IsSpatialNavigationEnabled(GetDocument().GetFrame()) || !SupportsFocus())
     return;
@@ skipping 73 matching lines @@
 
 #ifndef NDEBUG
 
 // For use in the debugger
 void dumpInnerHTML(blink::HTMLElement*);
 
 void dumpInnerHTML(blink::HTMLElement* element) {
   printf("%s\n", element->innerHTML().Ascii().Data());
 }
 #endif