Invalidate node list when associated form control element is removed
[WebKit.git] / Source / WebCore / html / HTMLFormElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004-2010, 2012-2016 Apple Inc. All rights reserved.
6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "HTMLFormElement.h"
27
28 #include "DOMFormData.h"
29 #include "DOMWindow.h"
30 #include "Document.h"
31 #include "ElementIterator.h"
32 #include "Event.h"
33 #include "EventNames.h"
34 #include "FormController.h"
35 #include "FormData.h"
36 #include "Frame.h"
37 #include "FrameLoader.h"
38 #include "FrameLoaderClient.h"
39 #include "HTMLFieldSetElement.h"
40 #include "HTMLFormControlsCollection.h"
41 #include "HTMLImageElement.h"
42 #include "HTMLInputElement.h"
43 #include "HTMLNames.h"
44 #include "HTMLObjectElement.h"
45 #include "HTMLTableElement.h"
46 #include "NodeRareData.h"
47 #include "Page.h"
48 #include "RadioNodeList.h"
49 #include "RenderTextControl.h"
50 #include "ScriptController.h"
51 #include "Settings.h"
52 #include <limits>
53 #include <wtf/Ref.h>
54 #include <wtf/SetForScope.h>
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59
60 HTMLFormElement::HTMLFormElement(const QualifiedName& tagName, Document& document)
61     : HTMLElement(tagName, document)
62 {
63     ASSERT(hasTagName(formTag));
64 }
65
66 Ref<HTMLFormElement> HTMLFormElement::create(Document& document)
67 {
68     return adoptRef(*new HTMLFormElement(formTag, document));
69 }
70
71 Ref<HTMLFormElement> HTMLFormElement::create(const QualifiedName& tagName, Document& document)
72 {
73     return adoptRef(*new HTMLFormElement(tagName, document));
74 }
75
76 HTMLFormElement::~HTMLFormElement()
77 {
78     document().formController().willDeleteForm(this);
79     if (!shouldAutocomplete())
80         document().unregisterForDocumentSuspensionCallbacks(this);
81
82     m_defaultButton = nullptr;
83     for (auto& associatedElement : m_associatedElements)
84         associatedElement->formWillBeDestroyed();
85     for (auto& imageElement : m_imageElements)
86         imageElement->m_form = nullptr;
87 }
88
89 bool HTMLFormElement::formWouldHaveSecureSubmission(const String& url)
90 {
91     return document().completeURL(url).protocolIs("https");
92 }
93
94 bool HTMLFormElement::rendererIsNeeded(const RenderStyle& style)
95 {
96     if (!m_wasDemoted)
97         return HTMLElement::rendererIsNeeded(style);
98
99     auto parent = parentNode();
100     auto parentRenderer = parent->renderer();
101
102     if (!parentRenderer)
103         return false;
104
105     // FIXME: Shouldn't we also check for table caption (see |formIsTablePart| below).
106     bool parentIsTableElementPart = (parentRenderer->isTable() && is<HTMLTableElement>(*parent))
107         || (parentRenderer->isTableRow() && parent->hasTagName(trTag))
108         || (parentRenderer->isTableSection() && parent->hasTagName(tbodyTag))
109         || (parentRenderer->isRenderTableCol() && parent->hasTagName(colTag))
110         || (parentRenderer->isTableCell() && parent->hasTagName(trTag));
111
112     if (!parentIsTableElementPart)
113         return true;
114
115     EDisplay display = style.display();
116     bool formIsTablePart = display == TABLE || display == INLINE_TABLE || display == TABLE_ROW_GROUP
117         || display == TABLE_HEADER_GROUP || display == TABLE_FOOTER_GROUP || display == TABLE_ROW
118         || display == TABLE_COLUMN_GROUP || display == TABLE_COLUMN || display == TABLE_CELL
119         || display == TABLE_CAPTION;
120
121     return formIsTablePart;
122 }
123
124 Node::InsertedIntoAncestorResult HTMLFormElement::insertedIntoAncestor(InsertionType insertionType, ContainerNode& parentOfInsertedTree)
125 {
126     HTMLElement::insertedIntoAncestor(insertionType, parentOfInsertedTree);
127     if (insertionType.connectedToDocument)
128         document().didAssociateFormControl(this);
129     return InsertedIntoAncestorResult::Done;
130 }
131
132 void HTMLFormElement::removedFromAncestor(RemovalType removalType, ContainerNode& oldParentOfRemovedTree)
133 {
134     Node& root = traverseToRootNode(); // Do not rely on rootNode() because our IsInTreeScope is outdated.
135     Vector<FormAssociatedElement*> associatedElements(m_associatedElements);
136     for (auto& associatedElement : associatedElements)
137         associatedElement->formOwnerRemovedFromTree(root);
138     HTMLElement::removedFromAncestor(removalType, oldParentOfRemovedTree);
139 }
140
141 void HTMLFormElement::handleLocalEvents(Event& event)
142 {
143     auto targetNode = event.target()->toNode();
144     if (event.eventPhase() != Event::CAPTURING_PHASE && targetNode && targetNode != this && (event.type() == eventNames().submitEvent || event.type() == eventNames().resetEvent)) {
145         event.stopPropagation();
146         return;
147     }
148     HTMLElement::handleLocalEvents(event);
149 }
150
151 unsigned HTMLFormElement::length() const
152 {
153     unsigned len = 0;
154     for (auto& associatedElement : m_associatedElements) {
155         if (associatedElement->isEnumeratable())
156             ++len;
157     }
158     return len;
159 }
160
161 HTMLElement* HTMLFormElement::item(unsigned index)
162 {
163     return elements()->item(index);
164 }
165
166 std::optional<Variant<RefPtr<RadioNodeList>, RefPtr<Element>>> HTMLFormElement::namedItem(const AtomicString& name)
167 {
168     auto namedItems = namedElements(name);
169
170     if (namedItems.isEmpty())
171         return std::nullopt;
172     if (namedItems.size() == 1)
173         return Variant<RefPtr<RadioNodeList>, RefPtr<Element>> { RefPtr<Element> { WTFMove(namedItems[0]) } };
174
175     return Variant<RefPtr<RadioNodeList>, RefPtr<Element>> { RefPtr<RadioNodeList> { radioNodeList(name) } };
176 }
177
178 Vector<AtomicString> HTMLFormElement::supportedPropertyNames() const
179 {
180     // FIXME: Should be implemented (only needed for enumeration with includeDontEnumProperties mode
181     // since this class is annotated with LegacyUnenumerableNamedProperties).
182     return { };
183 }
184
185 void HTMLFormElement::submitImplicitly(Event& event, bool fromImplicitSubmissionTrigger)
186 {
187     unsigned submissionTriggerCount = 0;
188     for (auto& formAssociatedElement : m_associatedElements) {
189         if (!is<HTMLFormControlElement>(*formAssociatedElement))
190             continue;
191         HTMLFormControlElement& formElement = downcast<HTMLFormControlElement>(*formAssociatedElement);
192         if (formElement.isSuccessfulSubmitButton()) {
193             if (formElement.renderer()) {
194                 formElement.dispatchSimulatedClick(&event);
195                 return;
196             }
197         } else if (formElement.canTriggerImplicitSubmission())
198             ++submissionTriggerCount;
199     }
200
201     if (!submissionTriggerCount)
202         return;
203
204     // Older iOS apps using WebViews expect the behavior of auto submitting multi-input forms.
205     if (fromImplicitSubmissionTrigger && (submissionTriggerCount == 1 || document().settings().allowMultiElementImplicitSubmission()))
206         prepareForSubmission(event);
207 }
208
209 static inline RefPtr<HTMLFormControlElement> submitElementFromEvent(const Event& event)
210 {
211     for (RefPtr<Node> node = event.target()->toNode(); node; node = node->parentNode()) {
212         if (is<HTMLFormControlElement>(*node))
213             return downcast<HTMLFormControlElement>(node.get());
214     }
215     return nullptr;
216 }
217
218 bool HTMLFormElement::validateInteractively()
219 {
220     for (auto& associatedElement : m_associatedElements) {
221         if (is<HTMLFormControlElement>(*associatedElement))
222             downcast<HTMLFormControlElement>(*associatedElement).hideVisibleValidationMessage();
223     }
224
225     Vector<RefPtr<HTMLFormControlElement>> unhandledInvalidControls;
226     if (!checkInvalidControlsAndCollectUnhandled(unhandledInvalidControls))
227         return true;
228     // Because the form has invalid controls, we abort the form submission and
229     // show a validation message on a focusable form control.
230
231     // Needs to update layout now because we'd like to call isFocusable(), which
232     // has !renderer()->needsLayout() assertion.
233     document().updateLayoutIgnorePendingStylesheets();
234
235     Ref<HTMLFormElement> protectedThis(*this);
236
237     // Focus on the first focusable control and show a validation message.
238     for (auto& control : unhandledInvalidControls) {
239         if (control->isConnected() && control->isFocusable()) {
240             control->focusAndShowValidationMessage();
241             break;
242         }
243     }
244
245     // Warn about all of unfocusable controls.
246     if (document().frame()) {
247         for (auto& control : unhandledInvalidControls) {
248             if (control->isConnected() && control->isFocusable())
249                 continue;
250             String message = makeString("An invalid form control with name='", control->name(), "' is not focusable.");
251             document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, message);
252         }
253     }
254
255     return false;
256 }
257
258 void HTMLFormElement::prepareForSubmission(Event& event)
259 {
260     if (!isConnected())
261         return;
262
263     RefPtr<Frame> frame = document().frame();
264     if (m_isSubmittingOrPreparingForSubmission || !frame)
265         return;
266
267     m_isSubmittingOrPreparingForSubmission = true;
268     m_shouldSubmit = false;
269
270     bool shouldValidate = document().page() && document().page()->settings().interactiveFormValidationEnabled() && !noValidate();
271
272     auto submitElement = submitElementFromEvent(event);
273     if (submitElement && submitElement->formNoValidate())
274         shouldValidate = false;
275
276     // Interactive validation must be done before dispatching the submit event.
277     if (shouldValidate && !validateInteractively()) {
278         m_isSubmittingOrPreparingForSubmission = false;
279         return;
280     }
281
282     auto targetFrame = frame->loader().findFrameForNavigation(effectiveTarget(&event), &document());
283     if (!targetFrame)
284         targetFrame = frame.get();
285     auto formState = FormState::create(*this, textFieldValues(), document(), NotSubmittedByJavaScript);
286     targetFrame->loader().client().dispatchWillSendSubmitEvent(WTFMove(formState));
287
288     Ref<HTMLFormElement> protectedThis(*this);
289
290     // Event handling can result in m_shouldSubmit becoming true, regardless of dispatchEvent() return value.
291     if (dispatchEvent(Event::create(eventNames().submitEvent, true, true)))
292         m_shouldSubmit = true;
293
294     m_isSubmittingOrPreparingForSubmission = false;
295
296     if (m_shouldSubmit)
297         submit(&event, true, true, NotSubmittedByJavaScript);
298 }
299
300 void HTMLFormElement::submit()
301 {
302     submit(0, false, true, NotSubmittedByJavaScript);
303 }
304
305 void HTMLFormElement::submitFromJavaScript()
306 {
307     submit(0, false, ScriptController::processingUserGesture(), SubmittedByJavaScript);
308 }
309
310 StringPairVector HTMLFormElement::textFieldValues() const
311 {
312     StringPairVector result;
313     result.reserveInitialCapacity(m_associatedElements.size());
314     for (auto& associatedElement : m_associatedElements) {
315         auto& element = associatedElement->asHTMLElement();
316         if (!is<HTMLInputElement>(element))
317             continue;
318         auto& input = downcast<HTMLInputElement>(element);
319         if (!input.isTextField())
320             continue;
321         result.uncheckedAppend({ input.name().string(), input.value() });
322     }
323     return result;
324 }
325
326 void HTMLFormElement::submit(Event* event, bool activateSubmitButton, bool processingUserGesture, FormSubmissionTrigger formSubmissionTrigger)
327 {
328     RefPtr<FrameView> view = document().view();
329     RefPtr<Frame> frame = document().frame();
330     if (!view || !frame)
331         return;
332
333     if (m_isSubmittingOrPreparingForSubmission) {
334         m_shouldSubmit = true;
335         return;
336     }
337
338     m_isSubmittingOrPreparingForSubmission = true;
339     m_wasUserSubmitted = processingUserGesture;
340
341     RefPtr<HTMLFormControlElement> firstSuccessfulSubmitButton;
342     bool needButtonActivation = activateSubmitButton; // do we need to activate a submit button?
343
344     for (auto& associatedElement : m_associatedElements) {
345         if (!is<HTMLFormControlElement>(*associatedElement))
346             continue;
347         if (needButtonActivation) {
348             HTMLFormControlElement& control = downcast<HTMLFormControlElement>(*associatedElement);
349             if (control.isActivatedSubmit())
350                 needButtonActivation = false;
351             else if (!firstSuccessfulSubmitButton && control.isSuccessfulSubmitButton())
352                 firstSuccessfulSubmitButton = &control;
353         }
354     }
355
356     if (needButtonActivation && firstSuccessfulSubmitButton)
357         firstSuccessfulSubmitButton->setActivatedSubmit(true);
358
359     auto protectedThis = makeRef(*this); // Form submission can execute arbitary JavaScript.
360
361     auto shouldLockHistory = processingUserGesture ? LockHistory::No : LockHistory::Yes;
362     frame->loader().submitForm(FormSubmission::create(*this, m_attributes, event, shouldLockHistory, formSubmissionTrigger));
363
364     if (needButtonActivation && firstSuccessfulSubmitButton)
365         firstSuccessfulSubmitButton->setActivatedSubmit(false);
366
367     m_shouldSubmit = false;
368     m_isSubmittingOrPreparingForSubmission = false;
369 }
370
371 void HTMLFormElement::reset()
372 {
373     RefPtr<Frame> frame = document().frame();
374     if (m_isInResetFunction || !frame)
375         return;
376
377     Ref<HTMLFormElement> protectedThis(*this);
378
379     SetForScope<bool> isInResetFunctionRestorer(m_isInResetFunction, true);
380
381     if (!dispatchEvent(Event::create(eventNames().resetEvent, true, true)))
382         return;
383
384     resetAssociatedFormControlElements();
385 }
386
387 void HTMLFormElement::resetAssociatedFormControlElements()
388 {
389     // Event handling can cause associated elements to be added or deleted while iterating
390     // over this collection. Protect these elements until we are done notifying them of
391     // the reset operation.
392     Vector<Ref<HTMLFormControlElement>> associatedFormControlElements;
393     associatedFormControlElements.reserveInitialCapacity(m_associatedElements.size());
394     for (auto* element : m_associatedElements) {
395         if (is<HTMLFormControlElement>(element))
396             associatedFormControlElements.uncheckedAppend(*downcast<HTMLFormControlElement>(element));
397     }
398     
399     for (auto& associatedFormControlElement : associatedFormControlElements)
400         associatedFormControlElement->reset();
401 }
402
403 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
404
405 // FIXME: We should look to share this code with class HTMLFormControlElement instead of duplicating the logic.
406
407 bool HTMLFormElement::shouldAutocorrect() const
408 {
409     const AtomicString& autocorrectValue = attributeWithoutSynchronization(autocorrectAttr);
410     if (!autocorrectValue.isEmpty())
411         return !equalLettersIgnoringASCIICase(autocorrectValue, "off");
412     if (RefPtr<HTMLFormElement> form = this->form())
413         return form->shouldAutocorrect();
414     return true;
415 }
416
417 #endif
418
419 void HTMLFormElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
420 {
421     if (name == actionAttr) {
422         m_attributes.parseAction(value);
423         
424         if (!m_attributes.action().isEmpty()) {
425             if (RefPtr<Frame> f = document().frame()) {
426                 Frame& topFrame = f->tree().top();
427                 topFrame.loader().mixedContentChecker().checkFormForMixedContent(topFrame.document()->securityOrigin(), document().completeURL(m_attributes.action()));
428             }
429         }
430     } else if (name == targetAttr)
431         m_attributes.setTarget(value);
432     else if (name == methodAttr)
433         m_attributes.updateMethodType(value);
434     else if (name == enctypeAttr)
435         m_attributes.updateEncodingType(value);
436     else if (name == accept_charsetAttr)
437         m_attributes.setAcceptCharset(value);
438     else if (name == autocompleteAttr) {
439         if (!shouldAutocomplete())
440             document().registerForDocumentSuspensionCallbacks(this);
441         else
442             document().unregisterForDocumentSuspensionCallbacks(this);
443     } else
444         HTMLElement::parseAttribute(name, value);
445 }
446
447 unsigned HTMLFormElement::formElementIndexWithFormAttribute(Element* element, unsigned rangeStart, unsigned rangeEnd)
448 {
449     if (m_associatedElements.isEmpty())
450         return 0;
451
452     ASSERT(rangeStart <= rangeEnd);
453
454     if (rangeStart == rangeEnd)
455         return rangeStart;
456
457     unsigned left = rangeStart;
458     unsigned right = rangeEnd - 1;
459     unsigned short position;
460
461     // Does binary search on m_associatedElements in order to find the index
462     // to be inserted.
463     while (left != right) {
464         unsigned middle = left + ((right - left) / 2);
465         ASSERT(middle < m_associatedElementsBeforeIndex || middle >= m_associatedElementsAfterIndex);
466         position = element->compareDocumentPosition(m_associatedElements[middle]->asHTMLElement());
467         if (position & DOCUMENT_POSITION_FOLLOWING)
468             right = middle;
469         else
470             left = middle + 1;
471     }
472     
473     ASSERT(left < m_associatedElementsBeforeIndex || left >= m_associatedElementsAfterIndex);
474     position = element->compareDocumentPosition(m_associatedElements[left]->asHTMLElement());
475     if (position & DOCUMENT_POSITION_FOLLOWING)
476         return left;
477     return left + 1;
478 }
479
480 unsigned HTMLFormElement::formElementIndex(FormAssociatedElement* associatedElement)
481 {
482     ASSERT(associatedElement);
483
484     HTMLElement& associatedHTMLElement = associatedElement->asHTMLElement();
485
486     // Treats separately the case where this element has the form attribute
487     // for performance consideration.
488     if (associatedHTMLElement.hasAttributeWithoutSynchronization(formAttr) && associatedHTMLElement.isConnected()) {
489         unsigned short position = compareDocumentPosition(associatedHTMLElement);
490         ASSERT_WITH_SECURITY_IMPLICATION(!(position & DOCUMENT_POSITION_DISCONNECTED));
491         if (position & DOCUMENT_POSITION_PRECEDING) {
492             ++m_associatedElementsBeforeIndex;
493             ++m_associatedElementsAfterIndex;
494             return HTMLFormElement::formElementIndexWithFormAttribute(&associatedHTMLElement, 0, m_associatedElementsBeforeIndex - 1);
495         }
496         if (position & DOCUMENT_POSITION_FOLLOWING && !(position & DOCUMENT_POSITION_CONTAINED_BY))
497             return HTMLFormElement::formElementIndexWithFormAttribute(&associatedHTMLElement, m_associatedElementsAfterIndex, m_associatedElements.size());
498     }
499
500     unsigned currentAssociatedElementsAfterIndex = m_associatedElementsAfterIndex;
501     ++m_associatedElementsAfterIndex;
502
503     if (!associatedHTMLElement.isDescendantOf(*this))
504         return currentAssociatedElementsAfterIndex;
505
506     // Check for the special case where this element is the very last thing in
507     // the form's tree of children; we don't want to walk the entire tree in that
508     // common case that occurs during parsing; instead we'll just return a value
509     // that says "add this form element to the end of the array".
510     auto descendants = descendantsOfType<HTMLElement>(*this);
511     auto it = descendants.beginAt(associatedHTMLElement);
512     auto end = descendants.end();
513     if (++it == end)
514         return currentAssociatedElementsAfterIndex;
515
516     unsigned i = m_associatedElementsBeforeIndex;
517     for (auto& element : descendants) {
518         if (&element == &associatedHTMLElement)
519             return i;
520         if (!is<HTMLFormControlElement>(element) && !is<HTMLObjectElement>(element))
521             continue;
522         if (element.form() != this)
523             continue;
524         ++i;
525     }
526     return currentAssociatedElementsAfterIndex;
527 }
528
529 void HTMLFormElement::registerFormElement(FormAssociatedElement* e)
530 {
531     m_associatedElements.insert(formElementIndex(e), e);
532
533     if (is<HTMLFormControlElement>(e)) {
534         HTMLFormControlElement& control = downcast<HTMLFormControlElement>(*e);
535         if (control.isSuccessfulSubmitButton()) {
536             if (!m_defaultButton)
537                 control.invalidateStyleForSubtree();
538             else
539                 resetDefaultButton();
540         }
541     }
542 }
543
544 void HTMLFormElement::removeFormElement(FormAssociatedElement* e)
545 {
546     unsigned index = m_associatedElements.find(e);
547     ASSERT_WITH_SECURITY_IMPLICATION(index < m_associatedElements.size());
548     if (index < m_associatedElementsBeforeIndex)
549         --m_associatedElementsBeforeIndex;
550     if (index < m_associatedElementsAfterIndex)
551         --m_associatedElementsAfterIndex;
552     removeFromPastNamesMap(e);
553     m_associatedElements.remove(index);
554
555     if (auto* nodeLists = this->nodeLists())
556         nodeLists->invalidateCaches();
557
558     if (e == m_defaultButton)
559         resetDefaultButton();
560 }
561
562 void HTMLFormElement::registerInvalidAssociatedFormControl(const HTMLFormControlElement& formControlElement)
563 {
564     ASSERT_WITH_MESSAGE(!is<HTMLFieldSetElement>(formControlElement), "FieldSet are never candidates for constraint validation.");
565     ASSERT(static_cast<const Element&>(formControlElement).matchesInvalidPseudoClass());
566
567     if (m_invalidAssociatedFormControls.isEmpty())
568         invalidateStyleForSubtree();
569     m_invalidAssociatedFormControls.add(&formControlElement);
570 }
571
572 void HTMLFormElement::removeInvalidAssociatedFormControlIfNeeded(const HTMLFormControlElement& formControlElement)
573 {
574     if (m_invalidAssociatedFormControls.remove(&formControlElement)) {
575         if (m_invalidAssociatedFormControls.isEmpty())
576             invalidateStyleForSubtree();
577     }
578 }
579
580 bool HTMLFormElement::isURLAttribute(const Attribute& attribute) const
581 {
582     return attribute.name() == actionAttr || HTMLElement::isURLAttribute(attribute);
583 }
584
585 void HTMLFormElement::registerImgElement(HTMLImageElement* e)
586 {
587     ASSERT(m_imageElements.find(e) == notFound);
588     m_imageElements.append(e);
589 }
590
591 void HTMLFormElement::removeImgElement(HTMLImageElement* e)
592 {
593     removeFromPastNamesMap(e);
594     bool removed = m_imageElements.removeFirst(e);
595     ASSERT_UNUSED(removed, removed);
596 }
597
598 Ref<HTMLFormControlsCollection> HTMLFormElement::elements()
599 {
600     return ensureRareData().ensureNodeLists().addCachedCollection<HTMLFormControlsCollection>(*this, FormControls);
601 }
602
603 Ref<HTMLCollection> HTMLFormElement::elementsForNativeBindings()
604 {
605     return elements();
606 }
607
608 String HTMLFormElement::name() const
609 {
610     return getNameAttribute();
611 }
612
613 bool HTMLFormElement::noValidate() const
614 {
615     return hasAttributeWithoutSynchronization(novalidateAttr);
616 }
617
618 // FIXME: This function should be removed because it does not do the same thing as the
619 // JavaScript binding for action, which treats action as a URL attribute. Last time I
620 // (Darin Adler) removed this, someone added it back, so I am leaving it in for now.
621 String HTMLFormElement::action() const
622 {
623     return attributeWithoutSynchronization(actionAttr);
624 }
625
626 void HTMLFormElement::setAction(const String &value)
627 {
628     setAttributeWithoutSynchronization(actionAttr, value);
629 }
630
631 void HTMLFormElement::setEnctype(const String &value)
632 {
633     setAttributeWithoutSynchronization(enctypeAttr, value);
634 }
635
636 String HTMLFormElement::method() const
637 {
638     return FormSubmission::Attributes::methodString(m_attributes.method());
639 }
640
641 void HTMLFormElement::setMethod(const String &value)
642 {
643     setAttributeWithoutSynchronization(methodAttr, value);
644 }
645
646 String HTMLFormElement::target() const
647 {
648     return attributeWithoutSynchronization(targetAttr);
649 }
650
651 String HTMLFormElement::effectiveTarget(const Event* event) const
652 {
653     if (auto* submitButton = findSubmitButton(event)) {
654         auto targetValue = submitButton->attributeWithoutSynchronization(formtargetAttr);
655         if (!targetValue.isNull())
656             return targetValue;
657     }
658
659     auto targetValue = target();
660     if (!targetValue.isNull())
661         return targetValue;
662
663     return document().baseTarget();
664 }
665
666 bool HTMLFormElement::wasUserSubmitted() const
667 {
668     return m_wasUserSubmitted;
669 }
670
671 HTMLFormControlElement* HTMLFormElement::findSubmitButton(const Event* event) const
672 {
673     if (event && event->target()) {
674         for (auto node = event->target()->toNode(); node; node = node->parentNode()) {
675             if (is<HTMLFormControlElement>(*node))
676                 return downcast<HTMLFormControlElement>(node.get());
677         }
678     }
679     return nullptr;
680 }
681
682 HTMLFormControlElement* HTMLFormElement::defaultButton() const
683 {
684     if (!m_defaultButton) {
685         for (auto& associatedElement : m_associatedElements) {
686             if (!is<HTMLFormControlElement>(*associatedElement))
687                 continue;
688             HTMLFormControlElement& control = downcast<HTMLFormControlElement>(*associatedElement);
689             if (control.isSuccessfulSubmitButton()) {
690                 m_defaultButton = &control;
691                 break;
692             }
693         }
694     }
695     return m_defaultButton;
696 }
697
698 void HTMLFormElement::resetDefaultButton()
699 {
700     if (!m_defaultButton) {
701         // Computing the default button is not cheap, we don't want to do it unless needed.
702         // If there was no default button set, the only style to invalidate is the element
703         // being added to the form. This is done explicitely in registerFormElement().
704         return;
705     }
706
707     RefPtr<HTMLFormControlElement> oldDefault = m_defaultButton;
708     m_defaultButton = nullptr;
709     defaultButton();
710     if (m_defaultButton != oldDefault) {
711         if (oldDefault)
712             oldDefault->invalidateStyleForSubtree();
713         if (m_defaultButton)
714             m_defaultButton->invalidateStyleForSubtree();
715     }
716 }
717
718 bool HTMLFormElement::checkValidity()
719 {
720     Vector<RefPtr<HTMLFormControlElement>> controls;
721     return !checkInvalidControlsAndCollectUnhandled(controls);
722 }
723
724 bool HTMLFormElement::checkInvalidControlsAndCollectUnhandled(Vector<RefPtr<HTMLFormControlElement>>& unhandledInvalidControls)
725 {
726     Ref<HTMLFormElement> protectedThis(*this);
727     // Copy m_associatedElements because event handlers called from
728     // HTMLFormControlElement::checkValidity() might change m_associatedElements.
729     Vector<RefPtr<FormAssociatedElement>> elements;
730     elements.reserveCapacity(m_associatedElements.size());
731     for (auto& associatedElement : m_associatedElements)
732         elements.append(associatedElement);
733     bool hasInvalidControls = false;
734     for (auto& element : elements) {
735         if (element->form() == this && is<HTMLFormControlElement>(*element)) {
736             HTMLFormControlElement& control = downcast<HTMLFormControlElement>(*element);
737             if (!control.checkValidity(&unhandledInvalidControls) && control.form() == this)
738                 hasInvalidControls = true;
739         }
740     }
741     return hasInvalidControls;
742 }
743
744 bool HTMLFormElement::reportValidity()
745 {
746     return validateInteractively();
747 }
748
749 #ifndef NDEBUG
750 void HTMLFormElement::assertItemCanBeInPastNamesMap(FormNamedItem* item) const
751 {
752     ASSERT_WITH_SECURITY_IMPLICATION(item);
753     HTMLElement& element = item->asHTMLElement();
754     ASSERT_WITH_SECURITY_IMPLICATION(element.form() == this);
755
756     if (item->isFormAssociatedElement()) {
757         ASSERT_WITH_SECURITY_IMPLICATION(m_associatedElements.find(static_cast<FormAssociatedElement*>(item)) != notFound);
758         return;
759     }
760
761     ASSERT_WITH_SECURITY_IMPLICATION(element.hasTagName(imgTag));
762     ASSERT_WITH_SECURITY_IMPLICATION(m_imageElements.find(&downcast<HTMLImageElement>(element)) != notFound);
763 }
764 #else
765 inline void HTMLFormElement::assertItemCanBeInPastNamesMap(FormNamedItem*) const
766 {
767 }
768 #endif
769
770 RefPtr<HTMLElement> HTMLFormElement::elementFromPastNamesMap(const AtomicString& pastName) const
771 {
772     if (pastName.isEmpty() || !m_pastNamesMap)
773         return nullptr;
774     FormNamedItem* item = m_pastNamesMap->get(pastName.impl());
775     if (!item)
776         return nullptr;
777     assertItemCanBeInPastNamesMap(item);
778     return &item->asHTMLElement();
779 }
780
781 void HTMLFormElement::addToPastNamesMap(FormNamedItem* item, const AtomicString& pastName)
782 {
783     assertItemCanBeInPastNamesMap(item);
784     if (pastName.isEmpty())
785         return;
786     if (!m_pastNamesMap)
787         m_pastNamesMap = std::make_unique<PastNamesMap>();
788     m_pastNamesMap->set(pastName.impl(), item);
789 }
790
791 void HTMLFormElement::removeFromPastNamesMap(FormNamedItem* item)
792 {
793     ASSERT(item);
794     if (!m_pastNamesMap)
795         return;
796
797     for (auto& pastName : m_pastNamesMap->values()) {
798         if (pastName == item)
799             pastName = nullptr; // Keep looping. Single element can have multiple names.
800     }
801 }
802
803 bool HTMLFormElement::matchesValidPseudoClass() const
804 {
805     return m_invalidAssociatedFormControls.isEmpty();
806 }
807
808 bool HTMLFormElement::matchesInvalidPseudoClass() const
809 {
810     return !m_invalidAssociatedFormControls.isEmpty();
811 }
812
813 // FIXME: Use Ref<HTMLElement> for the function result since there are no non-HTML elements returned here.
814 Vector<Ref<Element>> HTMLFormElement::namedElements(const AtomicString& name)
815 {
816     // http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#dom-form-nameditem
817     Vector<Ref<Element>> namedItems = elements()->namedItems(name);
818
819     auto elementFromPast = elementFromPastNamesMap(name);
820     if (namedItems.size() == 1 && namedItems.first().ptr() != elementFromPast)
821         addToPastNamesMap(downcast<HTMLElement>(namedItems.first().get()).asFormNamedItem(), name);
822     else if (elementFromPast && namedItems.isEmpty())
823         namedItems.append(*elementFromPast);
824
825     return namedItems;
826 }
827
828 void HTMLFormElement::resumeFromDocumentSuspension()
829 {
830     ASSERT(!shouldAutocomplete());
831
832     Ref<HTMLFormElement> protectedThis(*this);
833
834     resetAssociatedFormControlElements();
835 }
836
837 void HTMLFormElement::didMoveToNewDocument(Document& oldDocument, Document& newDocument)
838 {
839     if (!shouldAutocomplete()) {
840         oldDocument.unregisterForDocumentSuspensionCallbacks(this);
841         document().registerForDocumentSuspensionCallbacks(this);
842     }
843
844     HTMLElement::didMoveToNewDocument(oldDocument, newDocument);
845 }
846
847 bool HTMLFormElement::shouldAutocomplete() const
848 {
849     return !equalLettersIgnoringASCIICase(attributeWithoutSynchronization(autocompleteAttr), "off");
850 }
851
852 void HTMLFormElement::finishParsingChildren()
853 {
854     HTMLElement::finishParsingChildren();
855     document().formController().restoreControlStateIn(*this);
856 }
857
858 void HTMLFormElement::copyNonAttributePropertiesFromElement(const Element& source)
859 {
860     m_wasDemoted = static_cast<const HTMLFormElement&>(source).m_wasDemoted;
861     HTMLElement::copyNonAttributePropertiesFromElement(source);
862 }
863
864 HTMLFormElement* HTMLFormElement::findClosestFormAncestor(const Element& startElement)
865 {
866     return const_cast<HTMLFormElement*>(ancestorsOfType<HTMLFormElement>(startElement).first());
867 }
868
869 void HTMLFormElement::setAutocomplete(const AtomicString& value)
870 {
871     setAttributeWithoutSynchronization(autocompleteAttr, value);
872 }
873
874 const AtomicString& HTMLFormElement::autocomplete() const
875 {
876     static NeverDestroyed<AtomicString> on("on", AtomicString::ConstructFromLiteral);
877     static NeverDestroyed<AtomicString> off("off", AtomicString::ConstructFromLiteral);
878
879     return equalIgnoringASCIICase(attributeWithoutSynchronization(autocompleteAttr), "off") ? off : on;
880 }
881
882 } // namespace