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 137 matching lines @@
   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());
+      ListedElement::List elements(associatedElements());
       notifyFormRemovedFromTree(elements, root);
     } else {
-      FormAssociatedElement::List elements;
+      ListedElement::List elements;
       collectAssociatedElements(
           NodeTraversal::highestAncestorOrSelf(*insertionPoint), elements);
       notifyFormRemovedFromTree(elements, root);
       collectAssociatedElements(root, elements);
       notifyFormRemovedFromTree(elements, root);
     }
 
     if (!m_imageElementsAreDirty) {
       HeapVector<Member<HTMLImageElement>> images(imageElements());
       notifyFormRemovedFromTree(images, root);
@@ skipping 15 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 = associatedElements();
   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 = associatedElements();
   for (unsigned i = 0; i < elements.size(); ++i) {
-    FormAssociatedElement* formAssociatedElement = elements[i];
-    if (!formAssociatedElement->isFormControlElement())
+    ListedElement* ListedElement = elements[i];

[tkent, 2016/12/02 13:24:37]

Rename this variable to listedElement (lower l)

+    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 = associatedElements();
   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 213 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 = associatedElements();
   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) {
+void HTMLFormElement::associate(ListedElement& e) {
   m_associatedElementsAreDirty = true;
   m_associatedElements.clear();
   if (toHTMLElement(e).fastHasAttribute(formAttr))
     m_hasElementsAssociatedByFormAttribute = true;
 }
 
-void HTMLFormElement::disassociate(FormAssociatedElement& e) {
+void HTMLFormElement::disassociate(ListedElement& e) {
   m_associatedElementsAreDirty = true;
   m_associatedElements.clear();
   removeFromPastNamesMap(toHTMLElement(e));
 }
 
 bool HTMLFormElement::isURLAttribute(const Attribute& attribute) const {
   return attribute.name() == actionAttr ||
          HTMLElement::isURLAttribute(attribute);
 }
 
@@ skipping 18 matching lines @@
   m_hasElementsAssociatedByParser = true;
   UseCounter::count(document(), UseCounter::FormAssociationByParser);
 }
 
 HTMLFormControlsCollection* HTMLFormElement::elements() {
   return ensureCachedCollection<HTMLFormControlsCollection>(FormControls);
 }
 
 void HTMLFormElement::collectAssociatedElements(
     Node& root,
-    FormAssociatedElement::List& elements) const {
+    ListedElement::List& elements) const {
   elements.clear();
   for (HTMLElement& element : Traversal<HTMLElement>::startsAfter(root)) {
-    FormAssociatedElement* associatedElement = 0;
+    ListedElement* associatedElement = 0;

[tkent, 2016/12/02 13:24:37]

Rename this variable to listedElement.

     if (element.isFormControlElement())
       associatedElement = toHTMLFormControlElement(&element);
     else if (isHTMLObjectElement(element))
       associatedElement = toHTMLObjectElement(&element);
     else
       continue;
     if (associatedElement->form() == this)
       elements.append(associatedElement);
   }
 }
 
 // This function should be const conceptually. However we update some fields
 // because of lazy evaluation.
-const FormAssociatedElement::List& HTMLFormElement::associatedElements() const {
+const ListedElement::List& HTMLFormElement::associatedElements() const {
   if (!m_associatedElementsAreDirty)
     return m_associatedElements;
   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);
@@ skipping 65 matching lines @@
 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;
+  const ListedElement::List& associatedElements = this->associatedElements();

[tkent, 2016/12/02 13:24:37]

Rename this variable to listedElements.

+  HeapVector<Member<ListedElement>> elements;
   elements.reserveCapacity(associatedElements.size());
   for (unsigned i = 0; i < associatedElements.size(); ++i)
     elements.append(associatedElements[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) &&
@@ skipping 136 matching lines @@
   for (const auto& control : associatedElements()) {
     if (!control->isFormControlElement())
       continue;
     if (toHTMLFormControlElement(control)->canBeSuccessfulSubmitButton())
       toHTMLFormControlElement(control)->pseudoStateChanged(
           CSSSelector::PseudoDefault);
   }
 }
 
 }  // namespace blink