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