Use fastHasAttribute() / fastGetAttribute() when possible
[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 "Attribute.h"
29 #include "ControlStates.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 ? form : HTMLFormElement::findClosestFormAncestor(*this));
64     setHasCustomStyleResolveCallbacks();
65 }
66
67 HTMLFormControlElement::~HTMLFormControlElement()
68 {
69 }
70
71 String HTMLFormControlElement::formEnctype() const
72 {
73     const AtomicString& formEnctypeAttr = fastGetAttribute(formenctypeAttr);
74     if (formEnctypeAttr.isNull())
75         return emptyString();
76     return FormSubmission::Attributes::parseEncodingType(formEnctypeAttr);
77 }
78
79 void HTMLFormControlElement::setFormEnctype(const String& value)
80 {
81     setAttribute(formenctypeAttr, value);
82 }
83
84 String HTMLFormControlElement::formMethod() const
85 {
86     const AtomicString& formMethodAttr = fastGetAttribute(formmethodAttr);
87     if (formMethodAttr.isNull())
88         return emptyString();
89     return FormSubmission::Attributes::methodString(FormSubmission::Attributes::parseMethodType(formMethodAttr));
90 }
91
92 void HTMLFormControlElement::setFormMethod(const String& value)
93 {
94     setAttribute(formmethodAttr, value);
95 }
96
97 bool HTMLFormControlElement::formNoValidate() const
98 {
99     return fastHasAttribute(formnovalidateAttr);
100 }
101
102 bool HTMLFormControlElement::computeIsDisabledByFieldsetAncestor() const
103 {
104     Element* previousAncestor = nullptr;
105     for (Element* ancestor = parentElement(); ancestor; ancestor = ancestor->parentElement()) {
106         if (isHTMLFieldSetElement(ancestor) && ancestor->fastHasAttribute(disabledAttr)) {
107             HTMLFieldSetElement& fieldSetAncestor = toHTMLFieldSetElement(*ancestor);
108             bool isInFirstLegend = previousAncestor && isHTMLLegendElement(previousAncestor) && previousAncestor == fieldSetAncestor.legend();
109             return !isInFirstLegend;
110         }
111         previousAncestor = ancestor;
112     }
113     return false;
114 }
115
116 void HTMLFormControlElement::setAncestorDisabled(bool isDisabled)
117 {
118     ASSERT(computeIsDisabledByFieldsetAncestor() == isDisabled);
119     bool oldValue = m_disabledByAncestorFieldset;
120     m_disabledByAncestorFieldset = isDisabled;
121     if (oldValue != m_disabledByAncestorFieldset)
122         disabledStateChanged();
123 }
124
125 void HTMLFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
126 {
127     if (name == formAttr)
128         formAttributeChanged();
129     else if (name == disabledAttr) {
130         bool oldDisabled = m_disabled;
131         m_disabled = !value.isNull();
132         if (oldDisabled != m_disabled)
133             disabledAttributeChanged();
134     } else if (name == readonlyAttr) {
135         bool wasReadOnly = m_isReadOnly;
136         m_isReadOnly = !value.isNull();
137         if (wasReadOnly != m_isReadOnly)
138             readOnlyAttributeChanged();
139     } else if (name == requiredAttr) {
140         bool wasRequired = m_isRequired;
141         m_isRequired = !value.isNull();
142         if (wasRequired != m_isRequired)
143             requiredAttributeChanged();
144     } else
145         HTMLElement::parseAttribute(name, value);
146 }
147
148 void HTMLFormControlElement::disabledAttributeChanged()
149 {
150     disabledStateChanged();
151 }
152
153 void HTMLFormControlElement::disabledStateChanged()
154 {
155     setNeedsWillValidateCheck();
156     didAffectSelector(AffectedSelectorDisabled | AffectedSelectorEnabled);
157     if (renderer() && renderer()->style().hasAppearance())
158         renderer()->theme().stateChanged(*renderer(), ControlStates::EnabledState);
159 }
160
161 void HTMLFormControlElement::readOnlyAttributeChanged()
162 {
163     setNeedsWillValidateCheck();
164     setNeedsStyleRecalc();
165 }
166
167 void HTMLFormControlElement::requiredAttributeChanged()
168 {
169     setNeedsValidityCheck();
170     // Style recalculation is needed because style selectors may include
171     // :required and :optional pseudo-classes.
172     setNeedsStyleRecalc();
173 }
174
175 static bool shouldAutofocus(HTMLFormControlElement* element)
176 {
177     if (!element->renderer())
178         return false;
179     if (!element->fastHasAttribute(autofocusAttr))
180         return false;
181     if (!element->inDocument() || !element->document().renderView())
182         return false;
183     if (element->document().ignoreAutofocus())
184         return false;
185     if (element->document().isSandboxed(SandboxAutomaticFeatures)) {
186         // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
187         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."));
188         return false;
189     }
190     if (element->hasAutofocused())
191         return false;
192
193     // FIXME: Should this set of hasTagName checks be replaced by a
194     // virtual member function?
195     if (isHTMLInputElement(element))
196         return !toHTMLInputElement(element)->isInputTypeHidden();
197     if (element->hasTagName(selectTag))
198         return true;
199     if (element->hasTagName(keygenTag))
200         return true;
201     if (element->hasTagName(buttonTag))
202         return true;
203     if (isHTMLTextAreaElement(element))
204         return true;
205
206     return false;
207 }
208
209 void HTMLFormControlElement::didAttachRenderers()
210 {
211     // The call to updateFromElement() needs to go after the call through
212     // to the base class's attach() because that can sometimes do a close
213     // on the renderer.
214     if (renderer())
215         renderer()->updateFromElement();
216
217     if (shouldAutofocus(this)) {
218         setAutofocused();
219
220         RefPtr<HTMLFormControlElement> element = this;
221         Style::queuePostResolutionCallback([element] {
222             element->focus();
223         });
224     }
225 }
226
227 void HTMLFormControlElement::didMoveToNewDocument(Document* oldDocument)
228 {
229     FormAssociatedElement::didMoveToNewDocument(oldDocument);
230     HTMLElement::didMoveToNewDocument(oldDocument);
231 }
232
233 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode& insertionPoint)
234 {
235     if (document().hasDisabledFieldsetElement())
236         setAncestorDisabled(computeIsDisabledByFieldsetAncestor());
237     m_dataListAncestorState = Unknown;
238     setNeedsWillValidateCheck();
239     HTMLElement::insertedInto(insertionPoint);
240     FormAssociatedElement::insertedInto(insertionPoint);
241     return InsertionDone;
242 }
243
244 void HTMLFormControlElement::removedFrom(ContainerNode& insertionPoint)
245 {
246     m_validationMessage = nullptr;
247     if (m_disabledByAncestorFieldset)
248         setAncestorDisabled(computeIsDisabledByFieldsetAncestor());
249     m_dataListAncestorState = Unknown;
250     HTMLElement::removedFrom(insertionPoint);
251     FormAssociatedElement::removedFrom(insertionPoint);
252 }
253
254 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
255 {
256     m_wasChangedSinceLastFormControlChangeEvent = changed;
257 }
258
259 void HTMLFormControlElement::dispatchChangeEvent()
260 {
261     dispatchScopedEvent(Event::create(eventNames().changeEvent, true, false));
262 }
263
264 void HTMLFormControlElement::dispatchFormControlChangeEvent()
265 {
266     dispatchChangeEvent();
267     setChangedSinceLastFormControlChangeEvent(false);
268 }
269
270 void HTMLFormControlElement::dispatchFormControlInputEvent()
271 {
272     setChangedSinceLastFormControlChangeEvent(true);
273     HTMLElement::dispatchInputEvent();
274 }
275
276 bool HTMLFormControlElement::isDisabledFormControl() const
277 {
278     return m_disabled || m_disabledByAncestorFieldset;
279 }
280
281 bool HTMLFormControlElement::isRequired() const
282 {
283     return m_isRequired;
284 }
285
286 void HTMLFormControlElement::didRecalcStyle(Style::Change)
287 {
288     // updateFromElement() can cause the selection to change, and in turn
289     // trigger synchronous layout, so it must not be called during style recalc.
290     if (renderer()) {
291         RefPtr<HTMLFormControlElement> element = this;
292         Style::queuePostResolutionCallback([element]{
293             if (auto* renderer = element->renderer())
294                 renderer->updateFromElement();
295         });
296     }
297 }
298
299 bool HTMLFormControlElement::supportsFocus() const
300 {
301     return !isDisabledFormControl();
302 }
303
304 bool HTMLFormControlElement::isFocusable() const
305 {
306     // If there's a renderer, make sure the size isn't empty, but if there's no renderer,
307     // it might still be focusable if it's in a canvas subtree (handled in Node::isFocusable).
308     if (renderer() && (!renderer()->isBox() || toRenderBox(renderer())->size().isEmpty()))
309         return false;
310     // HTMLElement::isFocusable handles visibility and calls suportsFocus which
311     // will cover the disabled case.
312     return HTMLElement::isFocusable();
313 }
314
315 bool HTMLFormControlElement::isKeyboardFocusable(KeyboardEvent* event) const
316 {
317     if (isFocusable())
318         if (document().frame())
319             return document().frame()->eventHandler().tabsToAllFormControls(event);
320     return false;
321 }
322
323 bool HTMLFormControlElement::isMouseFocusable() const
324 {
325 #if PLATFORM(GTK)
326     return HTMLElement::isMouseFocusable();
327 #else
328     return false;
329 #endif
330 }
331
332 short HTMLFormControlElement::tabIndex() const
333 {
334     // Skip the supportsFocus check in HTMLElement.
335     return Element::tabIndex();
336 }
337
338 bool HTMLFormControlElement::recalcWillValidate() const
339 {
340     if (m_dataListAncestorState == Unknown) {
341         for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
342             if (ancestor->hasTagName(datalistTag)) {
343                 m_dataListAncestorState = InsideDataList;
344                 break;
345             }
346         }
347         if (m_dataListAncestorState == Unknown)
348             m_dataListAncestorState = NotInsideDataList;
349     }
350     return m_dataListAncestorState == NotInsideDataList && !isDisabledOrReadOnly();
351 }
352
353 bool HTMLFormControlElement::willValidate() const
354 {
355     if (!m_willValidateInitialized || m_dataListAncestorState == Unknown) {
356         m_willValidateInitialized = true;
357         bool newWillValidate = recalcWillValidate();
358         if (m_willValidate != newWillValidate) {
359             m_willValidate = newWillValidate;
360             const_cast<HTMLFormControlElement*>(this)->setNeedsValidityCheck();
361         }
362     } else {
363         // If the following assertion fails, setNeedsWillValidateCheck() is not
364         // called correctly when something which changes recalcWillValidate() result
365         // is updated.
366         ASSERT(m_willValidate == recalcWillValidate());
367     }
368     return m_willValidate;
369 }
370
371 void HTMLFormControlElement::setNeedsWillValidateCheck()
372 {
373     // We need to recalculate willValidate immediately because willValidate change can causes style change.
374     bool newWillValidate = recalcWillValidate();
375     if (m_willValidateInitialized && m_willValidate == newWillValidate)
376         return;
377     m_willValidateInitialized = true;
378     m_willValidate = newWillValidate;
379     setNeedsValidityCheck();
380     setNeedsStyleRecalc();
381     if (!m_willValidate)
382         hideVisibleValidationMessage();
383 }
384
385 void HTMLFormControlElement::updateVisibleValidationMessage()
386 {
387     Page* page = document().page();
388     if (!page)
389         return;
390     String message;
391     if (renderer() && willValidate())
392         message = validationMessage().stripWhiteSpace();
393     if (!m_validationMessage)
394         m_validationMessage = std::make_unique<ValidationMessage>(this);
395     m_validationMessage->updateValidationMessage(message);
396 }
397
398 void HTMLFormControlElement::hideVisibleValidationMessage()
399 {
400     if (m_validationMessage)
401         m_validationMessage->requestToHideMessage();
402 }
403
404 bool HTMLFormControlElement::checkValidity(Vector<RefPtr<FormAssociatedElement>>* unhandledInvalidControls)
405 {
406     if (!willValidate() || isValidFormControlElement())
407         return true;
408     // An event handler can deref this object.
409     Ref<HTMLFormControlElement> protect(*this);
410     Ref<Document> originalDocument(document());
411     bool needsDefaultAction = dispatchEvent(Event::create(eventNames().invalidEvent, false, true));
412     if (needsDefaultAction && unhandledInvalidControls && inDocument() && &originalDocument.get() == &document())
413         unhandledInvalidControls->append(this);
414     return false;
415 }
416
417 bool HTMLFormControlElement::isValidFormControlElement() const
418 {
419     // If the following assertion fails, setNeedsValidityCheck() is not called
420     // correctly when something which changes validity is updated.
421     ASSERT(m_isValid == valid());
422     return m_isValid;
423 }
424
425 void HTMLFormControlElement::setNeedsValidityCheck()
426 {
427     bool newIsValid = valid();
428     if (willValidate() && newIsValid != m_isValid) {
429         // Update style for pseudo classes such as :valid :invalid.
430         setNeedsStyleRecalc();
431     }
432     m_isValid = newIsValid;
433
434     // Updates only if this control already has a validtion message.
435     if (m_validationMessage && m_validationMessage->isVisible()) {
436         // Calls updateVisibleValidationMessage() even if m_isValid is not
437         // changed because a validation message can be chagned.
438         updateVisibleValidationMessage();
439     }
440 }
441
442 void HTMLFormControlElement::setCustomValidity(const String& error)
443 {
444     FormAssociatedElement::setCustomValidity(error);
445     setNeedsValidityCheck();
446 }
447
448 bool HTMLFormControlElement::validationMessageShadowTreeContains(const Node& node) const
449 {
450     return m_validationMessage && m_validationMessage->shadowTreeContains(node);
451 }
452
453 void HTMLFormControlElement::dispatchBlurEvent(PassRefPtr<Element> newFocusedElement)
454 {
455     HTMLElement::dispatchBlurEvent(newFocusedElement);
456     hideVisibleValidationMessage();
457 }
458
459 HTMLFormElement* HTMLFormControlElement::virtualForm() const
460 {
461     return FormAssociatedElement::form();
462 }
463
464 bool HTMLFormControlElement::isDefaultButtonForForm() const
465 {
466     return isSuccessfulSubmitButton() && form() && form()->defaultButton() == this;
467 }
468
469 #if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
470 // FIXME: We should look to share these methods with class HTMLFormElement instead of duplicating them.
471
472 bool HTMLFormControlElement::autocorrect() const
473 {
474     const AtomicString& autocorrectValue = fastGetAttribute(autocorrectAttr);
475     if (!autocorrectValue.isEmpty())
476         return !equalIgnoringCase(autocorrectValue, "off");
477     if (HTMLFormElement* form = this->form())
478         return form->autocorrect();
479     return true;
480 }
481
482 void HTMLFormControlElement::setAutocorrect(bool autocorrect)
483 {
484     setAttribute(autocorrectAttr, autocorrect ? AtomicString("on", AtomicString::ConstructFromLiteral) : AtomicString("off", AtomicString::ConstructFromLiteral));
485 }
486
487 WebAutocapitalizeType HTMLFormControlElement::autocapitalizeType() const
488 {
489     WebAutocapitalizeType type = autocapitalizeTypeForAttributeValue(fastGetAttribute(autocapitalizeAttr));
490     if (type == WebAutocapitalizeTypeDefault) {
491         if (HTMLFormElement* form = this->form())
492             return form->autocapitalizeType();
493     }
494     return type;
495 }
496
497 const AtomicString& HTMLFormControlElement::autocapitalize() const
498 {
499     return stringForAutocapitalizeType(autocapitalizeType());
500 }
501
502 void HTMLFormControlElement::setAutocapitalize(const AtomicString& value)
503 {
504     setAttribute(autocapitalizeAttr, value);
505 }
506 #endif
507
508 HTMLFormControlElement* HTMLFormControlElement::enclosingFormControlElement(Node* node)
509 {
510     for (; node; node = node->parentNode()) {
511         if (node->isElementNode() && toElement(node)->isFormControlElement())
512             return toHTMLFormControlElement(node);
513     }
514     return 0;
515 }
516
517 } // namespace Webcore