Adopt toHTMLTextAreaElement for code cleanup
[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 "ElementShadow.h"
30 #include "Event.h"
31 #include "EventHandler.h"
32 #include "EventNames.h"
33 #include "FeatureObserver.h"
34 #include "Frame.h"
35 #include "HTMLFieldSetElement.h"
36 #include "HTMLFormElement.h"
37 #include "HTMLInputElement.h"
38 #include "HTMLLegendElement.h"
39 #include "HTMLTextAreaElement.h"
40 #include "RenderBox.h"
41 #include "RenderTheme.h"
42 #include "ScriptEventListener.h"
43 #include "ValidationMessage.h"
44 #include "ValidityState.h"
45 #include <wtf/Vector.h>
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50 using namespace std;
51
52 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
53     : LabelableElement(tagName, document)
54     , m_disabled(false)
55     , m_isReadOnly(false)
56     , m_isRequired(false)
57     , m_valueMatchesRenderer(false)
58     , m_ancestorDisabledState(AncestorDisabledStateUnknown)
59     , m_dataListAncestorState(Unknown)
60     , m_willValidateInitialized(false)
61     , m_willValidate(true)
62     , m_isValid(true)
63     , m_wasChangedSinceLastFormControlChangeEvent(false)
64     , m_hasAutofocused(false)
65 {
66     setForm(form ? form : findFormAncestor());
67     setHasCustomStyleCallbacks();
68 }
69
70 HTMLFormControlElement::~HTMLFormControlElement()
71 {
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 void HTMLFormControlElement::updateAncestorDisabledState() const
106 {
107     HTMLFieldSetElement* fieldSetAncestor = 0;
108     ContainerNode* legendAncestor = 0;
109     for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
110         if (!legendAncestor && ancestor->hasTagName(legendTag))
111             legendAncestor = ancestor;
112         if (ancestor->hasTagName(fieldsetTag)) {
113             fieldSetAncestor = static_cast<HTMLFieldSetElement*>(ancestor);
114             break;
115         }
116     }
117     m_ancestorDisabledState = (fieldSetAncestor && fieldSetAncestor->isDisabledFormControl() && !(legendAncestor && legendAncestor == fieldSetAncestor->legend())) ? AncestorDisabledStateDisabled : AncestorDisabledStateEnabled;
118 }
119
120 void HTMLFormControlElement::ancestorDisabledStateWasChanged()
121 {
122     m_ancestorDisabledState = AncestorDisabledStateUnknown;
123     disabledAttributeChanged();
124 }
125
126 void HTMLFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
127 {
128     if (name == formAttr) {
129         formAttributeChanged();
130         FeatureObserver::observe(document(), FeatureObserver::FormAttribute);
131     } else if (name == disabledAttr) {
132         bool oldDisabled = m_disabled;
133         m_disabled = !value.isNull();
134         if (oldDisabled != m_disabled)
135             disabledAttributeChanged();
136     } else if (name == readonlyAttr) {
137         bool wasReadOnly = m_isReadOnly;
138         m_isReadOnly = !value.isNull();
139         if (wasReadOnly != m_isReadOnly) {
140             setNeedsWillValidateCheck();
141             setNeedsStyleRecalc();
142             if (renderer() && renderer()->style()->hasAppearance())
143                 renderer()->theme()->stateChanged(renderer(), ReadOnlyState);
144         }
145     } else if (name == requiredAttr) {
146         bool wasRequired = m_isRequired;
147         m_isRequired = !value.isNull();
148         if (wasRequired != m_isRequired)
149             requiredAttributeChanged();
150         FeatureObserver::observe(document(), FeatureObserver::RequiredAttribute);
151     } else if (name == autofocusAttr) {
152         HTMLElement::parseAttribute(name, value);
153         FeatureObserver::observe(document(), FeatureObserver::AutoFocusAttribute);
154     } else
155         HTMLElement::parseAttribute(name, value);
156 }
157
158 void HTMLFormControlElement::disabledAttributeChanged()
159 {
160     setNeedsWillValidateCheck();
161     didAffectSelector(AffectedSelectorDisabled | AffectedSelectorEnabled);
162     if (renderer() && renderer()->style()->hasAppearance())
163         renderer()->theme()->stateChanged(renderer(), EnabledState);
164 }
165
166 void HTMLFormControlElement::requiredAttributeChanged()
167 {
168     setNeedsValidityCheck();
169     // Style recalculation is needed because style selectors may include
170     // :required and :optional pseudo-classes.
171     setNeedsStyleRecalc();
172 }
173
174 static bool shouldAutofocus(HTMLFormControlElement* element)
175 {
176     if (!element->fastHasAttribute(autofocusAttr))
177         return false;
178     if (!element->renderer())
179         return false;
180     if (element->document()->ignoreAutofocus())
181         return false;
182     if (element->document()->isSandboxed(SandboxAutomaticFeatures)) {
183         // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
184         element->document()->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Blocked autofocusing on a form control because the form's frame is sandboxed and the 'allow-scripts' permission is not set.");
185         return false;
186     }
187     if (element->hasAutofocused())
188         return false;
189
190     // FIXME: Should this set of hasTagName checks be replaced by a
191     // virtual member function?
192     if (isHTMLInputElement(element))
193         return !toHTMLInputElement(element)->isInputTypeHidden();
194     if (element->hasTagName(selectTag))
195         return true;
196     if (element->hasTagName(keygenTag))
197         return true;
198     if (element->hasTagName(buttonTag))
199         return true;
200     if (isHTMLTextAreaElement(element))
201         return true;
202
203     return false;
204 }
205
206 static void focusPostAttach(Node* element, unsigned)
207
208     toElement(element)->focus(); 
209     element->deref(); 
210 }
211
212 void HTMLFormControlElement::attach(const AttachContext& context)
213 {
214     PostAttachCallbackDisabler disabler(this);
215
216     HTMLElement::attach(context);
217
218     // The call to updateFromElement() needs to go after the call through
219     // to the base class's attach() because that can sometimes do a close
220     // on the renderer.
221     if (renderer())
222         renderer()->updateFromElement();
223
224     if (shouldAutofocus(this)) {
225         setAutofocused();
226         ref();
227         queuePostAttachCallback(focusPostAttach, this);
228     }
229 }
230
231 void HTMLFormControlElement::didMoveToNewDocument(Document* oldDocument)
232 {
233     FormAssociatedElement::didMoveToNewDocument(oldDocument);
234     HTMLElement::didMoveToNewDocument(oldDocument);
235 }
236
237 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode* insertionPoint)
238 {
239     m_ancestorDisabledState = AncestorDisabledStateUnknown;
240     m_dataListAncestorState = Unknown;
241     setNeedsWillValidateCheck();
242     HTMLElement::insertedInto(insertionPoint);
243     FormAssociatedElement::insertedInto(insertionPoint);
244     return InsertionDone;
245 }
246
247 void HTMLFormControlElement::removedFrom(ContainerNode* insertionPoint)
248 {
249     m_validationMessage = nullptr;
250     m_ancestorDisabledState = AncestorDisabledStateUnknown;
251     m_dataListAncestorState = Unknown;
252     HTMLElement::removedFrom(insertionPoint);
253     FormAssociatedElement::removedFrom(insertionPoint);
254 }
255
256 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
257 {
258     m_wasChangedSinceLastFormControlChangeEvent = changed;
259 }
260
261 void HTMLFormControlElement::dispatchChangeEvent()
262 {
263     dispatchScopedEvent(Event::create(eventNames().changeEvent, true, false));
264 }
265
266 void HTMLFormControlElement::dispatchFormControlChangeEvent()
267 {
268     dispatchChangeEvent();
269     setChangedSinceLastFormControlChangeEvent(false);
270 }
271
272 void HTMLFormControlElement::dispatchFormControlInputEvent()
273 {
274     setChangedSinceLastFormControlChangeEvent(true);
275     HTMLElement::dispatchInputEvent();
276 }
277
278 bool HTMLFormControlElement::isDisabledFormControl() const
279 {
280     if (m_disabled)
281         return true;
282
283     if (m_ancestorDisabledState == AncestorDisabledStateUnknown)
284         updateAncestorDisabledState();
285     if (m_ancestorDisabledState == AncestorDisabledStateDisabled)
286         return true;
287     return HTMLElement::isDisabledFormControl();
288 }
289
290 bool HTMLFormControlElement::isRequired() const
291 {
292     return m_isRequired;
293 }
294
295 static void updateFromElementCallback(Node* node, unsigned)
296 {
297     ASSERT_ARG(node, node->isElementNode());
298     ASSERT_ARG(node, toElement(node)->isFormControlElement());
299     if (RenderObject* renderer = node->renderer())
300         renderer->updateFromElement();
301 }
302
303 void HTMLFormControlElement::didRecalcStyle(StyleChange)
304 {
305     // updateFromElement() can cause the selection to change, and in turn
306     // trigger synchronous layout, so it must not be called during style recalc.
307     if (renderer())
308         queuePostAttachCallback(updateFromElementCallback, this);
309 }
310
311 bool HTMLFormControlElement::supportsFocus() const
312 {
313     return !isDisabledFormControl();
314 }
315
316 bool HTMLFormControlElement::isFocusable() const
317 {
318     // If there's a renderer, make sure the size isn't empty, but if there's no renderer,
319     // it might still be focusable if it's in a canvas subtree (handled in Node::isFocusable).
320     if (renderer() && (!renderer()->isBox() || toRenderBox(renderer())->size().isEmpty()))
321         return false;
322     // HTMLElement::isFocusable handles visibility and calls suportsFocus which
323     // will cover the disabled case.
324     return HTMLElement::isFocusable();
325 }
326
327 bool HTMLFormControlElement::isKeyboardFocusable(KeyboardEvent* event) const
328 {
329     if (isFocusable())
330         if (document()->frame())
331             return document()->frame()->eventHandler()->tabsToAllFormControls(event);
332     return false;
333 }
334
335 bool HTMLFormControlElement::isMouseFocusable() const
336 {
337 #if PLATFORM(GTK) || PLATFORM(QT)
338     return HTMLElement::isMouseFocusable();
339 #else
340     return false;
341 #endif
342 }
343
344 short HTMLFormControlElement::tabIndex() const
345 {
346     // Skip the supportsFocus check in HTMLElement.
347     return Element::tabIndex();
348 }
349
350 bool HTMLFormControlElement::recalcWillValidate() const
351 {
352     if (m_dataListAncestorState == Unknown) {
353         for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
354             if (ancestor->hasTagName(datalistTag)) {
355                 m_dataListAncestorState = InsideDataList;
356                 break;
357             }
358         }
359         if (m_dataListAncestorState == Unknown)
360             m_dataListAncestorState = NotInsideDataList;
361     }
362     return m_dataListAncestorState == NotInsideDataList && !isDisabledOrReadOnly();
363 }
364
365 bool HTMLFormControlElement::willValidate() const
366 {
367     if (!m_willValidateInitialized || m_dataListAncestorState == Unknown) {
368         m_willValidateInitialized = true;
369         bool newWillValidate = recalcWillValidate();
370         if (m_willValidate != newWillValidate) {
371             m_willValidate = newWillValidate;
372             const_cast<HTMLFormControlElement*>(this)->setNeedsValidityCheck();
373         }
374     } else {
375         // If the following assertion fails, setNeedsWillValidateCheck() is not
376         // called correctly when something which changes recalcWillValidate() result
377         // is updated.
378         ASSERT(m_willValidate == recalcWillValidate());
379     }
380     return m_willValidate;
381 }
382
383 void HTMLFormControlElement::setNeedsWillValidateCheck()
384 {
385     // We need to recalculate willValidate immediately because willValidate change can causes style change.
386     bool newWillValidate = recalcWillValidate();
387     if (m_willValidateInitialized && m_willValidate == newWillValidate)
388         return;
389     m_willValidateInitialized = true;
390     m_willValidate = newWillValidate;
391     setNeedsValidityCheck();
392     setNeedsStyleRecalc();
393     if (!m_willValidate)
394         hideVisibleValidationMessage();
395 }
396
397 void HTMLFormControlElement::updateVisibleValidationMessage()
398 {
399     Page* page = document()->page();
400     if (!page)
401         return;
402     String message;
403     if (renderer() && willValidate())
404         message = validationMessage().stripWhiteSpace();
405     if (!m_validationMessage)
406         m_validationMessage = ValidationMessage::create(this);
407     m_validationMessage->updateValidationMessage(message);
408 }
409
410 void HTMLFormControlElement::hideVisibleValidationMessage()
411 {
412     if (m_validationMessage)
413         m_validationMessage->requestToHideMessage();
414 }
415
416 bool HTMLFormControlElement::checkValidity(Vector<RefPtr<FormAssociatedElement> >* unhandledInvalidControls)
417 {
418     if (!willValidate() || isValidFormControlElement())
419         return true;
420     // An event handler can deref this object.
421     RefPtr<HTMLFormControlElement> protector(this);
422     RefPtr<Document> originalDocument(document());
423     bool needsDefaultAction = dispatchEvent(Event::create(eventNames().invalidEvent, false, true));
424     if (needsDefaultAction && unhandledInvalidControls && inDocument() && originalDocument == document())
425         unhandledInvalidControls->append(this);
426     return false;
427 }
428
429 bool HTMLFormControlElement::isValidFormControlElement()
430 {
431     // If the following assertion fails, setNeedsValidityCheck() is not called
432     // correctly when something which changes validity is updated.
433     ASSERT(m_isValid == validity()->valid());
434     return m_isValid;
435 }
436
437 void HTMLFormControlElement::setNeedsValidityCheck()
438 {
439     bool newIsValid = validity()->valid();
440     if (willValidate() && newIsValid != m_isValid) {
441         // Update style for pseudo classes such as :valid :invalid.
442         setNeedsStyleRecalc();
443     }
444     m_isValid = newIsValid;
445
446     // Updates only if this control already has a validtion message.
447     if (m_validationMessage && m_validationMessage->isVisible()) {
448         // Calls updateVisibleValidationMessage() even if m_isValid is not
449         // changed because a validation message can be chagned.
450         updateVisibleValidationMessage();
451     }
452 }
453
454 void HTMLFormControlElement::setCustomValidity(const String& error)
455 {
456     FormAssociatedElement::setCustomValidity(error);
457     setNeedsValidityCheck();
458 }
459
460 bool HTMLFormControlElement::validationMessageShadowTreeContains(Node* node) const
461 {
462     return m_validationMessage && m_validationMessage->shadowTreeContains(node);
463 }
464
465 void HTMLFormControlElement::dispatchBlurEvent(PassRefPtr<Element> newFocusedElement)
466 {
467     HTMLElement::dispatchBlurEvent(newFocusedElement);
468     hideVisibleValidationMessage();
469 }
470
471 HTMLFormElement* HTMLFormControlElement::virtualForm() const
472 {
473     return FormAssociatedElement::form();
474 }
475
476 bool HTMLFormControlElement::isDefaultButtonForForm() const
477 {
478     return isSuccessfulSubmitButton() && form() && form()->defaultButton() == this;
479 }
480
481 HTMLFormControlElement* HTMLFormControlElement::enclosingFormControlElement(Node* node)
482 {
483     for (; node; node = node->parentNode()) {
484         if (node->isElementNode() && toElement(node)->isFormControlElement())
485             return static_cast<HTMLFormControlElement*>(node);
486     }
487     return 0;
488 }
489
490 } // namespace Webcore