Modern IDB: Land empty IDBCursor/Index IDL implementations.
[WebKit-https.git] / Source / WebCore / html / HTMLFormControlElement.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, 2005, 2006, 2007 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 "HTMLFormControlElement.h"
27
28 #include "ControlStates.h"
29 #include "ElementAncestorIterator.h"
30 #include "Event.h"
31 #include "EventHandler.h"
32 #include "EventNames.h"
33 #include "Frame.h"
34 #include "HTMLFieldSetElement.h"
35 #include "HTMLFormElement.h"
36 #include "HTMLInputElement.h"
37 #include "HTMLLegendElement.h"
38 #include "HTMLTextAreaElement.h"
39 #include "RenderBox.h"
40 #include "RenderTheme.h"
41 #include "ValidationMessage.h"
42 #include <wtf/Ref.h>
43 #include <wtf/Vector.h>
44
45 namespace WebCore {
46
47 using namespace HTMLNames;
48
49 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
50     : LabelableElement(tagName, document)
51     , m_disabled(false)
52     , m_isReadOnly(false)
53     , m_isRequired(false)
54     , m_valueMatchesRenderer(false)
55     , m_disabledByAncestorFieldset(false)
56     , m_dataListAncestorState(Unknown)
57     , m_willValidateInitialized(false)
58     , m_willValidate(true)
59     , m_isValid(true)
60     , m_wasChangedSinceLastFormControlChangeEvent(false)
61     , m_hasAutofocused(false)
62 {
63     setForm(form);
64     setHasCustomStyleResolveCallbacks();
65 }
66
67 HTMLFormControlElement::~HTMLFormControlElement()
68 {
69     // The calls willChangeForm() and didChangeForm() are virtual, we want the
70     // form to be reset while this object still exists.
71     setForm(nullptr);
72 }
73
74 String HTMLFormControlElement::formEnctype() const
75 {
76     const AtomicString& formEnctypeAttr = fastGetAttribute(formenctypeAttr);
77     if (formEnctypeAttr.isNull())
78         return emptyString();
79     return FormSubmission::Attributes::parseEncodingType(formEnctypeAttr);
80 }
81
82 void HTMLFormControlElement::setFormEnctype(const String& value)
83 {
84     setAttribute(formenctypeAttr, value);
85 }
86
87 String HTMLFormControlElement::formMethod() const
88 {
89     const AtomicString& formMethodAttr = fastGetAttribute(formmethodAttr);
90     if (formMethodAttr.isNull())
91         return emptyString();
92     return FormSubmission::Attributes::methodString(FormSubmission::Attributes::parseMethodType(formMethodAttr));
93 }
94
95 void HTMLFormControlElement::setFormMethod(const String& value)
96 {
97     setAttribute(formmethodAttr, value);
98 }
99
100 bool HTMLFormControlElement::formNoValidate() const
101 {
102     return fastHasAttribute(formnovalidateAttr);
103 }
104
105 bool HTMLFormControlElement::computeIsDisabledByFieldsetAncestor() const
106 {
107     Element* previousAncestor = nullptr;
108     for (Element* ancestor = parentElement(); ancestor; ancestor = ancestor->parentElement()) {
109         if (is<HTMLFieldSetElement>(*ancestor) && ancestor->fastHasAttribute(disabledAttr)) {
110             HTMLFieldSetElement& fieldSetAncestor = downcast<HTMLFieldSetElement>(*ancestor);
111             bool isInFirstLegend = is<HTMLLegendElement>(previousAncestor) && previousAncestor == fieldSetAncestor.legend();
112             return !isInFirstLegend;
113         }
114         previousAncestor = ancestor;
115     }
116     return false;
117 }
118
119 void HTMLFormControlElement::setAncestorDisabled(bool isDisabled)
120 {
121     ASSERT(computeIsDisabledByFieldsetAncestor() == isDisabled);
122     bool oldValue = m_disabledByAncestorFieldset;
123     m_disabledByAncestorFieldset = isDisabled;
124     if (oldValue != m_disabledByAncestorFieldset)
125         disabledStateChanged();
126 }
127
128 void HTMLFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
129 {
130     if (name == formAttr)
131         formAttributeChanged();
132     else if (name == disabledAttr) {
133         bool oldDisabled = m_disabled;
134         m_disabled = !value.isNull();
135         if (oldDisabled != m_disabled)
136             disabledAttributeChanged();
137     } else if (name == readonlyAttr) {
138         bool wasReadOnly = m_isReadOnly;
139         m_isReadOnly = !value.isNull();
140         if (wasReadOnly != m_isReadOnly)
141             readOnlyAttributeChanged();
142     } else if (name == requiredAttr) {
143         bool wasRequired = m_isRequired;
144         m_isRequired = !value.isNull();
145         if (wasRequired != m_isRequired)
146             requiredAttributeChanged();
147     } else
148         HTMLElement::parseAttribute(name, value);
149 }
150
151 void HTMLFormControlElement::disabledAttributeChanged()
152 {
153     disabledStateChanged();
154 }
155
156 void HTMLFormControlElement::disabledStateChanged()
157 {
158     setNeedsWillValidateCheck();
159     setNeedsStyleRecalc();
160     if (renderer() && renderer()->style().hasAppearance())
161         renderer()->theme().stateChanged(*renderer(), ControlStates::EnabledState);
162 }
163
164 void HTMLFormControlElement::readOnlyAttributeChanged()
165 {
166     setNeedsWillValidateCheck();
167     setNeedsStyleRecalc();
168 }
169
170 void HTMLFormControlElement::requiredAttributeChanged()
171 {
172     updateValidity();
173     // Style recalculation is needed because style selectors may include
174     // :required and :optional pseudo-classes.
175     setNeedsStyleRecalc();
176 }
177
178 static bool shouldAutofocus(HTMLFormControlElement* element)
179 {
180     if (!element->renderer())
181         return false;
182     if (!element->fastHasAttribute(autofocusAttr))
183         return false;
184     if (!element->inDocument() || !element->document().renderView())
185         return false;
186     if (element->document().isSandboxed(SandboxAutomaticFeatures)) {
187         // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
188         element->document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, ASCIILiteral("Blocked autofocusing on a form control because the form's frame is sandboxed and the 'allow-scripts' permission is not set."));
189         return false;
190     }
191     if (element->hasAutofocused())
192         return false;
193
194     // FIXME: Should this set of hasTagName checks be replaced by a
195     // virtual member function?
196     if (is<HTMLInputElement>(*element))
197         return !downcast<HTMLInputElement>(*element).isInputTypeHidden();
198     if (element->hasTagName(selectTag))
199         return true;
200     if (element->hasTagName(keygenTag))
201         return true;
202     if (element->hasTagName(buttonTag))
203         return true;
204     if (is<HTMLTextAreaElement>(*element))
205         return true;
206
207     return false;
208 }
209
210 void HTMLFormControlElement::didAttachRenderers()
211 {
212     // The call to updateFromElement() needs to go after the call through
213     // to the base class's attach() because that can sometimes do a close
214     // on the renderer.
215     if (renderer())
216         renderer()->updateFromElement();
217
218     if (shouldAutofocus(this)) {
219         setAutofocused();
220
221         RefPtr<HTMLFormControlElement> element = this;
222         Style::queuePostResolutionCallback([element] {
223             element->focus();
224         });
225     }
226 }
227
228 void HTMLFormControlElement::didMoveToNewDocument(Document* oldDocument)
229 {
230     FormAssociatedElement::didMoveToNewDocument(oldDocument);
231     HTMLElement::didMoveToNewDocument(oldDocument);
232 }
233
234 static void addInvalidElementToAncestorFromInsertionPoint(const HTMLFormControlElement& element, ContainerNode* insertionPoint)
235 {
236     if (!is<Element>(insertionPoint))
237         return;
238
239     for (auto& ancestor : lineageOfType<HTMLFieldSetElement>(downcast<Element>(*insertionPoint)))
240         ancestor.addInvalidDescendant(element);
241 }
242
243 static void removeInvalidElementToAncestorFromInsertionPoint(const HTMLFormControlElement& element, ContainerNode* insertionPoint)
244 {
245     if (!is<Element>(insertionPoint))
246         return;
247
248     for (auto& ancestor : lineageOfType<HTMLFieldSetElement>(downcast<Element>(*insertionPoint)))
249         ancestor.removeInvalidDescendant(element);
250 }
251
252 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode& insertionPoint)
253 {
254     if (willValidate() && !isValidFormControlElement())
255         addInvalidElementToAncestorFromInsertionPoint(*this, &insertionPoint);
256
257     if (document().hasDisabledFieldsetElement())
258         setAncestorDisabled(computeIsDisabledByFieldsetAncestor());
259     m_dataListAncestorState = Unknown;
260     setNeedsWillValidateCheck();
261     HTMLElement::insertedInto(insertionPoint);
262     FormAssociatedElement::insertedInto(insertionPoint);
263     return InsertionShouldCallFinishedInsertingSubtree;
264 }
265
266 void HTMLFormControlElement::finishedInsertingSubtree()
267 {
268     resetFormOwner();
269 }
270
271 void HTMLFormControlElement::removedFrom(ContainerNode& insertionPoint)
272 {
273     bool wasMatchingInvalidPseudoClass = willValidate() && !isValidFormControlElement();
274
275     m_validationMessage = nullptr;
276     if (m_disabledByAncestorFieldset)
277         setAncestorDisabled(computeIsDisabledByFieldsetAncestor());
278     m_dataListAncestorState = Unknown;
279     HTMLElement::removedFrom(insertionPoint);
280     FormAssociatedElement::removedFrom(insertionPoint);
281
282     if (wasMatchingInvalidPseudoClass)
283         removeInvalidElementToAncestorFromInsertionPoint(*this, &insertionPoint);
284 }
285
286 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
287 {
288     m_wasChangedSinceLastFormControlChangeEvent = changed;
289 }
290
291 void HTMLFormControlElement::dispatchChangeEvent()
292 {
293     dispatchScopedEvent(Event::create(eventNames().changeEvent, true, false));
294 }
295
296 void HTMLFormControlElement::dispatchFormControlChangeEvent()
297 {
298     dispatchChangeEvent();
299     setChangedSinceLastFormControlChangeEvent(false);
300 }
301
302 void HTMLFormControlElement::dispatchFormControlInputEvent()
303 {
304     setChangedSinceLastFormControlChangeEvent(true);
305     HTMLElement::dispatchInputEvent();
306 }
307
308 bool HTMLFormControlElement::isDisabledFormControl() const
309 {
310     return m_disabled || m_disabledByAncestorFieldset;
311 }
312
313 bool HTMLFormControlElement::isRequired() const
314 {
315     return m_isRequired;
316 }
317
318 void HTMLFormControlElement::didRecalcStyle(Style::Change)
319 {
320     // updateFromElement() can cause the selection to change, and in turn
321     // trigger synchronous layout, so it must not be called during style recalc.
322     if (renderer()) {
323         RefPtr<HTMLFormControlElement> element = this;
324         Style::queuePostResolutionCallback([element]{
325             if (auto* renderer = element->renderer())
326                 renderer->updateFromElement();
327         });
328     }
329 }
330
331 bool HTMLFormControlElement::supportsFocus() const
332 {
333     return !isDisabledFormControl();
334 }
335
336 bool HTMLFormControlElement::isFocusable() const
337 {
338     // If there's a renderer, make sure the size isn't empty, but if there's no renderer,
339     // it might still be focusable if it's in a canvas subtree (handled in Node::isFocusable).
340     if (renderer() && (!is<RenderBox>(*renderer()) || downcast<RenderBox>(*renderer()).size().isEmpty()))
341         return false;
342     // HTMLElement::isFocusable handles visibility and calls suportsFocus which
343     // will cover the disabled case.
344     return HTMLElement::isFocusable();
345 }
346
347 bool HTMLFormControlElement::isKeyboardFocusable(KeyboardEvent* event) const
348 {
349     if (isFocusable())
350         if (document().frame())
351             return document().frame()->eventHandler().tabsToAllFormControls(event);
352     return false;
353 }
354
355 bool HTMLFormControlElement::isMouseFocusable() const
356 {
357 #if PLATFORM(GTK)
358     return HTMLElement::isMouseFocusable();
359 #else
360     return false;
361 #endif
362 }
363
364 bool HTMLFormControlElement::matchesValidPseudoClass() const
365 {
366     return willValidate() && isValidFormControlElement();
367 }
368
369 bool HTMLFormControlElement::matchesInvalidPseudoClass() const
370 {
371     return willValidate() && !isValidFormControlElement();
372 }
373
374 short HTMLFormControlElement::tabIndex() const
375 {
376     // Skip the supportsFocus check in HTMLElement.
377     return Element::tabIndex();
378 }
379
380 bool HTMLFormControlElement::computeWillValidate() const
381 {
382     if (m_dataListAncestorState == Unknown) {
383         for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
384             if (ancestor->hasTagName(datalistTag)) {
385                 m_dataListAncestorState = InsideDataList;
386                 break;
387             }
388         }
389         if (m_dataListAncestorState == Unknown)
390             m_dataListAncestorState = NotInsideDataList;
391     }
392     return m_dataListAncestorState == NotInsideDataList && !isDisabledOrReadOnly();
393 }
394
395 bool HTMLFormControlElement::willValidate() const
396 {
397     if (!m_willValidateInitialized || m_dataListAncestorState == Unknown) {
398         m_willValidateInitialized = true;
399         bool newWillValidate = computeWillValidate();
400         if (m_willValidate != newWillValidate)
401             m_willValidate = newWillValidate;
402     } else {
403         // If the following assertion fails, setNeedsWillValidateCheck() is not
404         // called correctly when something which changes computeWillValidate() result
405         // is updated.
406         ASSERT(m_willValidate == computeWillValidate());
407     }
408     return m_willValidate;
409 }
410
411 void HTMLFormControlElement::setNeedsWillValidateCheck()
412 {
413     // We need to recalculate willValidate immediately because willValidate change can causes style change.
414     bool newWillValidate = computeWillValidate();
415     if (m_willValidateInitialized && m_willValidate == newWillValidate)
416         return;
417
418     bool wasValid = m_isValid;
419
420     m_willValidateInitialized = true;
421     m_willValidate = newWillValidate;
422
423     updateValidity();
424     setNeedsStyleRecalc();
425
426     if (!m_willValidate && !wasValid) {
427         removeInvalidElementToAncestorFromInsertionPoint(*this, parentNode());
428         if (HTMLFormElement* form = this->form())
429             form->removeInvalidAssociatedFormControlIfNeeded(*this);
430     }
431
432     if (!m_willValidate)
433         hideVisibleValidationMessage();
434 }
435
436 void HTMLFormControlElement::updateVisibleValidationMessage()
437 {
438     Page* page = document().page();
439     if (!page)
440         return;
441     String message;
442     if (renderer() && willValidate())
443         message = validationMessage().stripWhiteSpace();
444     if (!m_validationMessage)
445         m_validationMessage = std::make_unique<ValidationMessage>(this);
446     m_validationMessage->updateValidationMessage(message);
447 }
448
449 void HTMLFormControlElement::hideVisibleValidationMessage()
450 {
451     if (m_validationMessage)
452         m_validationMessage->requestToHideMessage();
453 }
454
455 bool HTMLFormControlElement::checkValidity(Vector<RefPtr<FormAssociatedElement>>* unhandledInvalidControls)
456 {
457     if (!willValidate() || isValidFormControlElement())
458         return true;
459     // An event handler can deref this object.
460     Ref<HTMLFormControlElement> protect(*this);
461     Ref<Document> originalDocument(document());
462     bool needsDefaultAction = dispatchEvent(Event::create(eventNames().invalidEvent, false, true));
463     if (needsDefaultAction && unhandledInvalidControls && inDocument() && originalDocument.ptr() == &document())
464         unhandledInvalidControls->append(this);
465     return false;
466 }
467
468 inline bool HTMLFormControlElement::isValidFormControlElement() const
469 {
470     // If the following assertion fails, updateValidity() is not called
471     // correctly when something which changes validity is updated.
472     ASSERT(m_isValid == valid());
473     return m_isValid;
474 }
475
476 void HTMLFormControlElement::willChangeForm()
477 {
478     if (HTMLFormElement* form = this->form())
479         form->removeInvalidAssociatedFormControlIfNeeded(*this);
480     FormAssociatedElement::willChangeForm();
481 }
482
483 void HTMLFormControlElement::didChangeForm()
484 {
485     FormAssociatedElement::didChangeForm();
486     if (HTMLFormElement* form = this->form()) {
487         if (m_willValidateInitialized && m_willValidate && !isValidFormControlElement())
488             form->registerInvalidAssociatedFormControl(*this);
489     }
490 }
491
492 void HTMLFormControlElement::updateValidity()
493 {
494     bool willValidate = this->willValidate();
495     bool wasValid = m_isValid;
496
497     m_isValid = valid();
498
499     if (willValidate && m_isValid != wasValid) {
500         // Update style for pseudo classes such as :valid :invalid.
501         setNeedsStyleRecalc();
502
503         if (!m_isValid) {
504             addInvalidElementToAncestorFromInsertionPoint(*this, parentNode());
505             if (HTMLFormElement* form = this->form())
506                 form->registerInvalidAssociatedFormControl(*this);
507         } else {
508             removeInvalidElementToAncestorFromInsertionPoint(*this, parentNode());
509             if (HTMLFormElement* form = this->form())
510                 form->removeInvalidAssociatedFormControlIfNeeded(*this);
511         }
512     }
513
514     // Updates only if this control already has a validtion message.
515     if (m_validationMessage && m_validationMessage->isVisible()) {
516         // Calls updateVisibleValidationMessage() even if m_isValid is not
517         // changed because a validation message can be chagned.
518         updateVisibleValidationMessage();
519     }
520 }
521
522 void HTMLFormControlElement::setCustomValidity(const String& error)
523 {
524     FormAssociatedElement::setCustomValidity(error);
525     updateValidity();
526 }
527
528 bool HTMLFormControlElement::validationMessageShadowTreeContains(const Node& node) const
529 {
530     return m_validationMessage && m_validationMessage->shadowTreeContains(node);
531 }
532
533 void HTMLFormControlElement::dispatchBlurEvent(RefPtr<Element>&& newFocusedElement)
534 {
535     HTMLElement::dispatchBlurEvent(WTF::move(newFocusedElement));
536     hideVisibleValidationMessage();
537 }
538
539 HTMLFormElement* HTMLFormControlElement::virtualForm() const
540 {
541     return FormAssociatedElement::form();
542 }
543
544 bool HTMLFormControlElement::isDefaultButtonForForm() const
545 {
546     return isSuccessfulSubmitButton() && form() && form()->defaultButton() == this;
547 }
548
549 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
550 // FIXME: We should look to share these methods with class HTMLFormElement instead of duplicating them.
551
552 bool HTMLFormControlElement::autocorrect() const
553 {
554     const AtomicString& autocorrectValue = fastGetAttribute(autocorrectAttr);
555     if (!autocorrectValue.isEmpty())
556         return !equalIgnoringCase(autocorrectValue, "off");
557     if (HTMLFormElement* form = this->form())
558         return form->autocorrect();
559     return true;
560 }
561
562 void HTMLFormControlElement::setAutocorrect(bool autocorrect)
563 {
564     setAttribute(autocorrectAttr, autocorrect ? AtomicString("on", AtomicString::ConstructFromLiteral) : AtomicString("off", AtomicString::ConstructFromLiteral));
565 }
566
567 WebAutocapitalizeType HTMLFormControlElement::autocapitalizeType() const
568 {
569     WebAutocapitalizeType type = autocapitalizeTypeForAttributeValue(fastGetAttribute(autocapitalizeAttr));
570     if (type == WebAutocapitalizeTypeDefault) {
571         if (HTMLFormElement* form = this->form())
572             return form->autocapitalizeType();
573     }
574     return type;
575 }
576
577 const AtomicString& HTMLFormControlElement::autocapitalize() const
578 {
579     return stringForAutocapitalizeType(autocapitalizeType());
580 }
581
582 void HTMLFormControlElement::setAutocapitalize(const AtomicString& value)
583 {
584     setAttribute(autocapitalizeAttr, value);
585 }
586 #endif
587
588 HTMLFormControlElement* HTMLFormControlElement::enclosingFormControlElement(Node* node)
589 {
590     for (; node; node = node->parentNode()) {
591         if (is<HTMLFormControlElement>(*node))
592             return downcast<HTMLFormControlElement>(node);
593     }
594     return nullptr;
595 }
596
597 } // namespace Webcore