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