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