Use new is*Element() helper functions even more in HTML code

Source/core/html/HTMLFormElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * 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
@@ skipping 78 matching lines @@
 
 bool HTMLFormElement::rendererIsNeeded(const RenderStyle& style)
 {
     if (!m_wasDemoted)
         return HTMLElement::rendererIsNeeded(style);
 
     ContainerNode* node = parentNode();
     RenderObject* parentRenderer = node->renderer();
     // FIXME: Shouldn't we also check for table caption (see |formIsTablePart| below).
     // FIXME: This check is not correct for Shadow DOM.
-    bool parentIsTableElementPart = (parentRenderer->isTable() && node->hasTagName(tableTag))
-        || (parentRenderer->isTableRow() && node->hasTagName(trTag))
+    bool parentIsTableElementPart = (parentRenderer->isTable() && isHTMLTableElement(*node))
+        || (parentRenderer->isTableRow() && isHTMLTableRowElement(*node))
         || (parentRenderer->isTableSection() && node->hasTagName(tbodyTag))
         || (parentRenderer->isRenderTableCol() && node->hasTagName(colTag))
-        || (parentRenderer->isTableCell() && node->hasTagName(trTag));
+        || (parentRenderer->isTableCell() && isHTMLTableRowElement(*node));
 
     if (!parentIsTableElementPart)
         return true;
 
     EDisplay display = style.display();
     bool formIsTablePart = display == TABLE || display == INLINE_TABLE || display == TABLE_ROW_GROUP
         || display == TABLE_HEADER_GROUP || display == TABLE_FOOTER_GROUP || display == TABLE_ROW
         || display == TABLE_COLUMN_GROUP || display == TABLE_COLUMN || display == TABLE_CELL
         || display == TABLE_CAPTION;
 
@@ skipping 209 matching lines @@
 }
 
 void HTMLFormElement::getTextFieldValues(StringPairVector& fieldNamesAndValues) const
 {
     ASSERT_ARG(fieldNamesAndValues, fieldNamesAndValues.isEmpty());
 
     const Vector<FormAssociatedElement*>& elements = associatedElements();
     fieldNamesAndValues.reserveCapacity(elements.size());
     for (unsigned i = 0; i < elements.size(); ++i) {
         FormAssociatedElement* control = elements[i];
-        HTMLElement* element = toHTMLElement(control);
-        if (!element->hasTagName(inputTag))
+        HTMLElement& element = toHTMLElement(*control);
+        if (!isHTMLInputElement(element))
             continue;
 
-        HTMLInputElement* input = toHTMLInputElement(element);
-        if (!input->isTextField())
+        HTMLInputElement& input = toHTMLInputElement(element);
+        if (!input.isTextField())
             continue;
 
-        fieldNamesAndValues.append(make_pair(input->name().string(), input->value()));
+        fieldNamesAndValues.append(make_pair(input.name().string(), input.value()));
     }
 }
 
 void HTMLFormElement::submitDialog(PassRefPtr<FormSubmission> formSubmission)
 {
     for (Node* node = this; node; node = node->parentOrShadowHostNode()) {
-        if (node->hasTagName(dialogTag)) {
-            toHTMLDialogElement(node)->closeDialog(formSubmission->result());
+        if (isHTMLDialogElement(*node)) {
+            toHTMLDialogElement(*node).closeDialog(formSubmission->result());
             return;
         }
     }
 }
 
 void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool processingUserGesture, FormSubmissionTrigger formSubmissionTrigger)
 {
     FrameView* view = document().view();
     LocalFrame* frame = document().frame();
     if (!view || !frame || !frame->page())
@@ skipping 210 matching lines @@
 }
 
 PassRefPtr<HTMLCollection> HTMLFormElement::elements()
 {
     return ensureCachedHTMLCollection(FormControls);
 }
 
 void HTMLFormElement::collectAssociatedElements(Node& root, Vector<FormAssociatedElement*>& elements) const
 {
     elements.clear();
-    for (Node* node = &root; node; node = NodeTraversal::next(*node)) {
-        if (!node->isHTMLElement())
-            continue;
-        FormAssociatedElement* element = 0;
-        if (toElement(node)->isFormControlElement())
-            element = toHTMLFormControlElement(node);
-        else if (node->hasTagName(objectTag))
-            element = toHTMLObjectElement(node);
+    for (HTMLElement* element = Traversal<HTMLElement>::firstWithin(root); element; element = Traversal<HTMLElement>::next(*element)) {
+        FormAssociatedElement* associatedElement = 0;
+        if (element->isFormControlElement())
+            associatedElement = toHTMLFormControlElement(element);
+        else if (isHTMLObjectElement(*element))
+            associatedElement = toHTMLObjectElement(element);
         else
             continue;
-        if (element->form()== this)
-            elements.append(element);
+        if (associatedElement->form()== this)
+            elements.append(associatedElement);
     }
 }
 
 // This function should be const conceptually. However we update some fields
 // because of lazy evaluation.
 const Vector<FormAssociatedElement*>& HTMLFormElement::associatedElements() const
 {
     if (!m_associatedElementsAreDirty)
         return m_associatedElements;
     HTMLFormElement* mutableThis = const_cast<HTMLFormElement*>(this);
     Node* scope = mutableThis;
     if (m_hasElementsAssociatedByParser)
         scope = &highestAncestor();
     if (inDocument() && treeScope().idTargetObserverRegistry().hasObservers(fastGetAttribute(idAttr)))
         scope = &treeScope().rootNode();
     ASSERT(scope);
     collectAssociatedElements(*scope, mutableThis->m_associatedElements);
     mutableThis->m_associatedElementsAreDirty = false;
     return m_associatedElements;
 }
 
 void HTMLFormElement::collectImageElements(Node& root, Vector<HTMLImageElement*>& elements)
 {
     elements.clear();
-    for (Node* node = &root; node; node = NodeTraversal::next(*node)) {
-        if (node->isHTMLElement() && node->hasTagName(imgTag) && toHTMLElement(node)->formOwner() == this)
-            elements.append(toHTMLImageElement(node));
+    for (HTMLImageElement* image = Traversal<HTMLImageElement>::firstWithin(root); image; image = Traversal<HTMLImageElement>::next(*image)) {
+        if (image->formOwner() == this)
+            elements.append(image);
     }
 }
 
 const Vector<HTMLImageElement*>& HTMLFormElement::imageElements()
 {
     if (!m_imageElementsAreDirty)
         return m_imageElements;
     collectImageElements(m_hasElementsAssociatedByParser ? highestAncestor() : *this, m_imageElements);
     m_imageElementsAreDirty = false;
     return m_imageElements;
@@ skipping 85 matching lines @@
 
 Element* HTMLFormElement::elementFromPastNamesMap(const AtomicString& pastName)
 {
     if (pastName.isEmpty() || !m_pastNamesMap)
         return 0;
     Element* element = m_pastNamesMap->get(pastName);
 #if !ASSERT_DISABLED
     if (!element)
         return 0;
     ASSERT_WITH_SECURITY_IMPLICATION(toHTMLElement(element)->formOwner() == this);
-    if (element->hasTagName(imgTag)) {
+    if (isHTMLImageElement(*element)) {
         ASSERT_WITH_SECURITY_IMPLICATION(imageElements().find(element) != kNotFound);
-    } else if (element->hasTagName(objectTag)) {
+    } else if (isHTMLObjectElement(*element)) {
         ASSERT_WITH_SECURITY_IMPLICATION(associatedElements().find(toHTMLObjectElement(element)) != kNotFound);
     } else {
         ASSERT_WITH_SECURITY_IMPLICATION(associatedElements().find(toHTMLFormControlElement(element)) != kNotFound);
     }
 #endif
     return element;
 }
 
 void HTMLFormElement::addToPastNamesMap(Element* element, const AtomicString& pastName)
 {
@@ skipping 66 matching lines @@
     Vector<RefPtr<Element> > elements;
     getNamedElements(name, elements);
     ASSERT(!elements.isEmpty());
 
     if (elements.size() == 1) {
         returnValue1Enabled = true;
         returnValue1 = elements.at(0);
         return;
     }
 
-    bool onlyMatchImg = elements.size() && elements.at(0)->hasTagName(imgTag);
+    bool onlyMatchImg = !elements.isEmpty() && isHTMLImageElement(*elements.first());
     returnValue0Enabled = true;
     returnValue0 = radioNodeList(name, onlyMatchImg);
 }
 
 void HTMLFormElement::setDemoted(bool demoted)
 {
     if (demoted)
         UseCounter::count(document(), UseCounter::DemotedFormElement);
     m_wasDemoted = demoted;
 }
 
 } // namespace