Rename FormAssociatedElement to ListedElement

third_party/WebKit/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
@@ skipping 49 matching lines @@
 #include "wtf/AutoReset.h"
 #include "wtf/text/AtomicString.h"
 #include <limits>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 HTMLFormElement::HTMLFormElement(Document& document)
     : HTMLElement(formTag, document),
-      m_associatedElementsAreDirty(false),
+      m_listedElementsAreDirty(false),
       m_imageElementsAreDirty(false),
       m_hasElementsAssociatedByParser(false),
       m_hasElementsAssociatedByFormAttribute(false),
       m_didFinishParsingChildren(false),
       m_isInResetFunction(false),
       m_wasDemoted(false) {}
 
 HTMLFormElement* HTMLFormElement::create(Document& document) {
   UseCounter::count(document, UseCounter::FormElement);
   return new HTMLFormElement(document);
 }
 
 HTMLFormElement::~HTMLFormElement() {}
 
 DEFINE_TRACE(HTMLFormElement) {
   visitor->trace(m_pastNamesMap);
   visitor->trace(m_radioButtonGroupScope);
-  visitor->trace(m_associatedElements);
+  visitor->trace(m_listedElements);
   visitor->trace(m_imageElements);
   visitor->trace(m_plannedNavigation);
   HTMLElement::trace(visitor);
 }
 
 bool HTMLFormElement::matchesValidityPseudoClasses() const {
   return true;
 }
 
 bool HTMLFormElement::isValidElement() {
@@ skipping 48 matching lines @@
 void notifyFormRemovedFromTree(const T& elements, Node& root) {
   for (const auto& element : elements)
     element->formRemovedFromTree(root);
 }
 
 void HTMLFormElement::removedFrom(ContainerNode* insertionPoint) {
   // We don't need to take care of form association by 'form' content
   // attribute becuse IdTargetObserver handles it.
   if (m_hasElementsAssociatedByParser) {
     Node& root = NodeTraversal::highestAncestorOrSelf(*this);
-    if (!m_associatedElementsAreDirty) {
-      FormAssociatedElement::List elements(associatedElements());
+    if (!m_listedElementsAreDirty) {
+      ListedElement::List elements(listedElements());
       notifyFormRemovedFromTree(elements, root);
     } else {
-      FormAssociatedElement::List elements;
-      collectAssociatedElements(
+      ListedElement::List elements;
+      collectlistedElements(
           NodeTraversal::highestAncestorOrSelf(*insertionPoint), elements);
       notifyFormRemovedFromTree(elements, root);
-      collectAssociatedElements(root, elements);
+      collectlistedElements(root, elements);
       notifyFormRemovedFromTree(elements, root);
     }
 
     if (!m_imageElementsAreDirty) {
       HeapVector<Member<HTMLImageElement>> images(imageElements());
       notifyFormRemovedFromTree(images, root);
     } else {
       HeapVector<Member<HTMLImageElement>> images;
       collectImageElements(
           NodeTraversal::highestAncestorOrSelf(*insertionPoint), images);
@@ skipping 11 matching lines @@
   if (event.eventPhase() != Event::kCapturingPhase && targetNode &&
       targetNode != this && (event.type() == EventTypeNames::submit ||
                              event.type() == EventTypeNames::reset)) {
     event.stopPropagation();
     return;
   }
   HTMLElement::handleLocalEvents(event);
 }
 
 unsigned HTMLFormElement::length() const {
-  const FormAssociatedElement::List& elements = associatedElements();
+  const ListedElement::List& elements = listedElements();
   unsigned len = 0;
   for (unsigned i = 0; i < elements.size(); ++i) {
     if (elements[i]->isEnumeratable())
       ++len;
   }
   return len;
 }
 
 HTMLElement* HTMLFormElement::item(unsigned index) {
   return elements()->item(index);
 }
 
 void HTMLFormElement::submitImplicitly(Event* event,
                                        bool fromImplicitSubmissionTrigger) {
   int submissionTriggerCount = 0;
   bool seenDefaultButton = false;
-  const FormAssociatedElement::List& elements = associatedElements();
+  const ListedElement::List& elements = listedElements();
   for (unsigned i = 0; i < elements.size(); ++i) {
-    FormAssociatedElement* formAssociatedElement = elements[i];
-    if (!formAssociatedElement->isFormControlElement())
+    ListedElement* ListedElement = elements[i];
+    if (!ListedElement->isFormControlElement())
       continue;
-    HTMLFormControlElement* control =
-        toHTMLFormControlElement(formAssociatedElement);
+    HTMLFormControlElement* control = toHTMLFormControlElement(ListedElement);
     if (!seenDefaultButton && control->canBeSuccessfulSubmitButton()) {
       if (fromImplicitSubmissionTrigger)
         seenDefaultButton = true;
       if (control->isSuccessfulSubmitButton()) {
         control->dispatchSimulatedClick(event);
         return;
       }
       if (fromImplicitSubmissionTrigger) {
         // Default (submit) button is not activated; no implicit submission.
         return;
       }
     } else if (control->canTriggerImplicitSubmission()) {
       ++submissionTriggerCount;
     }
   }
   if (fromImplicitSubmissionTrigger && submissionTriggerCount == 1)
     prepareForSubmission(event, nullptr);
 }
 
 bool HTMLFormElement::validateInteractively() {
   UseCounter::count(document(), UseCounter::FormValidationStarted);
-  const FormAssociatedElement::List& elements = associatedElements();
+  const ListedElement::List& elements = listedElements();
   for (unsigned i = 0; i < elements.size(); ++i) {
     if (elements[i]->isFormControlElement())
       toHTMLFormControlElement(elements[i])->hideVisibleValidationMessage();
   }
 
   HeapVector<Member<HTMLFormControlElement>> unhandledInvalidControls;
   if (!checkInvalidControlsAndCollectUnhandled(
           &unhandledInvalidControls, CheckValidityDispatchInvalidEvent))
     return true;
   UseCounter::count(document(), UseCounter::FormValidationAbortedSubmission);
@@ skipping 110 matching lines @@
 
   // Delay dispatching 'close' to dialog until done submitting.
   EventQueueScope scopeForDialogClose;
   AutoReset<bool> submitScope(&m_isSubmitting, true);
 
   if (event && !submitButton) {
     // In a case of implicit submission without a submit button, 'submit'
     // event handler might add a submit button. We search for a submit
     // button again.
     // TODO(tkent): Do we really need to activate such submit button?
-    for (const auto& associatedElement : associatedElements()) {
-      if (!associatedElement->isFormControlElement())
+    for (const auto& listedElement : listedElements()) {
+      if (!listedElement->isFormControlElement())
         continue;
-      HTMLFormControlElement* control =
-          toHTMLFormControlElement(associatedElement);
+      HTMLFormControlElement* control = toHTMLFormControlElement(listedElement);
       DCHECK(!control->isActivatedSubmit());
       if (control->isSuccessfulSubmitButton()) {
         submitButton = control;
         break;
       }
     }
   }
 
   FormSubmission* formSubmission =
       FormSubmission::create(this, m_attributes, event, submitButton);
@@ skipping 78 matching lines @@
     return;
 
   m_isInResetFunction = true;
 
   if (dispatchEvent(Event::createCancelableBubble(EventTypeNames::reset)) !=
       DispatchEventResult::NotCanceled) {
     m_isInResetFunction = false;
     return;
   }
 
-  const FormAssociatedElement::List& elements = associatedElements();
+  const ListedElement::List& elements = listedElements();
   for (unsigned i = 0; i < elements.size(); ++i) {
     if (elements[i]->isFormControlElement())
       toHTMLFormControlElement(elements[i])->reset();
   }
 
   m_isInResetFunction = false;
 }
 
 void HTMLFormElement::parseAttribute(const QualifiedName& name,
                                      const AtomicString& oldValue,
@@ skipping 20 matching lines @@
     m_attributes.updateMethodType(value);
   } else if (name == enctypeAttr) {
     m_attributes.updateEncodingType(value);
   } else if (name == accept_charsetAttr) {
     m_attributes.setAcceptCharset(value);
   } else {
     HTMLElement::parseAttribute(name, oldValue, value);
   }
 }
 
-void HTMLFormElement::associate(FormAssociatedElement& e) {
-  m_associatedElementsAreDirty = true;
-  m_associatedElements.clear();
+void HTMLFormElement::associate(ListedElement& e) {
+  m_listedElementsAreDirty = true;
+  m_listedElements.clear();
   if (toHTMLElement(e).fastHasAttribute(formAttr))
     m_hasElementsAssociatedByFormAttribute = true;
 }
 
-void HTMLFormElement::disassociate(FormAssociatedElement& e) {
-  m_associatedElementsAreDirty = true;
-  m_associatedElements.clear();
+void HTMLFormElement::disassociate(ListedElement& e) {
+  m_listedElementsAreDirty = true;
+  m_listedElements.clear();
   removeFromPastNamesMap(toHTMLElement(e));
 }
 
 bool HTMLFormElement::isURLAttribute(const Attribute& attribute) const {
   return attribute.name() == actionAttr ||
          HTMLElement::isURLAttribute(attribute);
 }
 
 bool HTMLFormElement::hasLegalLinkAttribute(const QualifiedName& name) const {
   return name == actionAttr || HTMLElement::hasLegalLinkAttribute(name);
@@ skipping 14 matching lines @@
   if (!m_didFinishParsingChildren)
     return;
   m_hasElementsAssociatedByParser = true;
   UseCounter::count(document(), UseCounter::FormAssociationByParser);
 }
 
 HTMLFormControlsCollection* HTMLFormElement::elements() {
   return ensureCachedCollection<HTMLFormControlsCollection>(FormControls);
 }
 
-void HTMLFormElement::collectAssociatedElements(
+void HTMLFormElement::collectlistedElements(
     Node& root,
-    FormAssociatedElement::List& elements) const {
+    ListedElement::List& elements) const {
   elements.clear();
   for (HTMLElement& element : Traversal<HTMLElement>::startsAfter(root)) {
-    FormAssociatedElement* associatedElement = 0;
+    ListedElement* listedElement = 0;
     if (element.isFormControlElement())
-      associatedElement = toHTMLFormControlElement(&element);
+      listedElement = toHTMLFormControlElement(&element);
     else if (isHTMLObjectElement(element))
-      associatedElement = toHTMLObjectElement(&element);
+      listedElement = toHTMLObjectElement(&element);
     else
       continue;
-    if (associatedElement->form() == this)
-      elements.append(associatedElement);
+    if (listedElement->form() == this)
+      elements.append(listedElement);
   }
 }
 
 // This function should be const conceptually. However we update some fields
 // because of lazy evaluation.
-const FormAssociatedElement::List& HTMLFormElement::associatedElements() const {
-  if (!m_associatedElementsAreDirty)
-    return m_associatedElements;
+const ListedElement::List& HTMLFormElement::listedElements() const {
+  if (!m_listedElementsAreDirty)
+    return m_listedElements;
   HTMLFormElement* mutableThis = const_cast<HTMLFormElement*>(this);
   Node* scope = mutableThis;
   if (m_hasElementsAssociatedByParser)
     scope = &NodeTraversal::highestAncestorOrSelf(*mutableThis);
   if (isConnected() && m_hasElementsAssociatedByFormAttribute)
     scope = &treeScope().rootNode();
   DCHECK(scope);
-  collectAssociatedElements(*scope, mutableThis->m_associatedElements);
-  mutableThis->m_associatedElementsAreDirty = false;
-  return m_associatedElements;
+  collectlistedElements(*scope, mutableThis->m_listedElements);
+  mutableThis->m_listedElementsAreDirty = false;
+  return m_listedElements;
 }
 
 void HTMLFormElement::collectImageElements(
     Node& root,
     HeapVector<Member<HTMLImageElement>>& elements) {
   elements.clear();
   for (HTMLImageElement& image :
        Traversal<HTMLImageElement>::startsAfter(root)) {
     if (image.formOwner() == this)
       elements.append(&image);
@@ skipping 33 matching lines @@
 
 String HTMLFormElement::method() const {
   return FormSubmission::Attributes::methodString(m_attributes.method());
 }
 
 void HTMLFormElement::setMethod(const AtomicString& value) {
   setAttribute(methodAttr, value);
 }
 
 HTMLFormControlElement* HTMLFormElement::findDefaultButton() const {
-  for (const auto& element : associatedElements()) {
+  for (const auto& element : listedElements()) {
     if (!element->isFormControlElement())
       continue;
     HTMLFormControlElement* control = toHTMLFormControlElement(element);
     if (control->canBeSuccessfulSubmitButton())
       return control;
   }
   return nullptr;
 }
 
 bool HTMLFormElement::checkValidity() {
   return !checkInvalidControlsAndCollectUnhandled(
       0, CheckValidityDispatchInvalidEvent);
 }
 
 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(
     HeapVector<Member<HTMLFormControlElement>>* unhandledInvalidControls,
     CheckValidityEventBehavior eventBehavior) {
-  // Copy associatedElements because event handlers called from
-  // HTMLFormControlElement::checkValidity() might change associatedElements.
-  const FormAssociatedElement::List& associatedElements =
-      this->associatedElements();
-  HeapVector<Member<FormAssociatedElement>> elements;
-  elements.reserveCapacity(associatedElements.size());
-  for (unsigned i = 0; i < associatedElements.size(); ++i)
-    elements.append(associatedElements[i]);
+  // Copy listedElements because event handlers called from
+  // HTMLFormControlElement::checkValidity() might change listedElements.
+  const ListedElement::List& listedElements = this->listedElements();
+  HeapVector<Member<ListedElement>> elements;
+  elements.reserveCapacity(listedElements.size());
+  for (unsigned i = 0; i < listedElements.size(); ++i)
+    elements.append(listedElements[i]);
   int invalidControlsCount = 0;
   for (unsigned i = 0; i < elements.size(); ++i) {
     if (elements[i]->form() == this && elements[i]->isFormControlElement()) {
       HTMLFormControlElement* control =
           toHTMLFormControlElement(elements[i].get());
       if (control->isSubmittableElement() &&
           !control->checkValidity(unhandledInvalidControls, eventBehavior) &&
           control->formOwner() == this) {
         ++invalidControlsCount;
         if (!unhandledInvalidControls &&
@@ skipping 14 matching lines @@
   if (pastName.isEmpty() || !m_pastNamesMap)
     return 0;
   Element* element = m_pastNamesMap->get(pastName);
 #if DCHECK_IS_ON()
   if (!element)
     return 0;
   SECURITY_DCHECK(toHTMLElement(element)->formOwner() == this);
   if (isHTMLImageElement(*element)) {
     SECURITY_DCHECK(imageElements().find(element) != kNotFound);
   } else if (isHTMLObjectElement(*element)) {
-    SECURITY_DCHECK(associatedElements().find(toHTMLObjectElement(element)) !=
+    SECURITY_DCHECK(listedElements().find(toHTMLObjectElement(element)) !=
                     kNotFound);
   } else {
-    SECURITY_DCHECK(associatedElements().find(
-                        toHTMLFormControlElement(element)) != kNotFound);
+    SECURITY_DCHECK(listedElements().find(toHTMLFormControlElement(element)) !=
+                    kNotFound);
   }
 #endif
   return element;
 }
 
 void HTMLFormElement::addToPastNamesMap(Element* element,
                                         const AtomicString& pastName) {
   if (pastName.isEmpty())
     return;
   if (!m_pastNamesMap)
@@ skipping 84 matching lines @@
   returnValue.setRadioNodeList(radioNodeList(name, onlyMatchImg));
 }
 
 void HTMLFormElement::setDemoted(bool demoted) {
   if (demoted)
     UseCounter::count(document(), UseCounter::DemotedFormElement);
   m_wasDemoted = demoted;
 }
 
 void HTMLFormElement::invalidateDefaultButtonStyle() const {
-  for (const auto& control : associatedElements()) {
+  for (const auto& control : listedElements()) {
     if (!control->isFormControlElement())
       continue;
     if (toHTMLFormControlElement(control)->canBeSuccessfulSubmitButton())
       toHTMLFormControlElement(control)->pseudoStateChanged(
           CSSSelector::PseudoDefault);
   }
 }
 
 }  // namespace blink