Protect frames during style and layout changes
[WebKit-https.git] / Source / WebCore / html / HTMLTextAreaElement.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-2019 Apple Inc. All rights reserved.
6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
7  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  *
24  */
25
26 #include "config.h"
27 #include "HTMLTextAreaElement.h"
28
29 #include "BeforeTextInsertedEvent.h"
30 #include "CSSValueKeywords.h"
31 #include "DOMFormData.h"
32 #include "Document.h"
33 #include "Editor.h"
34 #include "ElementChildIterator.h"
35 #include "Event.h"
36 #include "EventNames.h"
37 #include "FormController.h"
38 #include "Frame.h"
39 #include "FrameSelection.h"
40 #include "HTMLNames.h"
41 #include "HTMLParserIdioms.h"
42 #include "LocalizedStrings.h"
43 #include "RenderTextControlMultiLine.h"
44 #include "ShadowRoot.h"
45 #include "Text.h"
46 #include "TextControlInnerElements.h"
47 #include "TextIterator.h"
48 #include "TextNodeTraversal.h"
49 #include <wtf/IsoMallocInlines.h>
50 #include <wtf/Ref.h>
51 #include <wtf/StdLibExtras.h>
52
53 namespace WebCore {
54
55 WTF_MAKE_ISO_ALLOCATED_IMPL(HTMLTextAreaElement);
56
57 using namespace HTMLNames;
58
59 static const int defaultRows = 2;
60 static const int defaultCols = 20;
61
62 // On submission, LF characters are converted into CRLF.
63 // This function returns number of characters considering this.
64 static inline unsigned computeLengthForSubmission(StringView text, unsigned numberOfLineBreaks)
65 {
66     return numGraphemeClusters(text) + numberOfLineBreaks;
67 }
68
69 static unsigned numberOfLineBreaks(StringView text)
70 {
71     unsigned length = text.length();
72     unsigned count = 0;
73     for (unsigned i = 0; i < length; i++) {
74         if (text[i] == '\n')
75             count++;
76     }
77     return count;
78 }
79
80 static inline unsigned computeLengthForSubmission(StringView text)
81 {
82     return numGraphemeClusters(text) + numberOfLineBreaks(text);
83 }
84
85 static inline unsigned upperBoundForLengthForSubmission(StringView text, unsigned numberOfLineBreaks)
86 {
87     return text.length() + numberOfLineBreaks;
88 }
89
90 HTMLTextAreaElement::HTMLTextAreaElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
91     : HTMLTextFormControlElement(tagName, document, form)
92     , m_rows(defaultRows)
93     , m_cols(defaultCols)
94 {
95     ASSERT(hasTagName(textareaTag));
96     setFormControlValueMatchesRenderer(true);
97 }
98
99 Ref<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
100 {
101     auto textArea = adoptRef(*new HTMLTextAreaElement(tagName, document, form));
102     textArea->ensureUserAgentShadowRoot();
103     return textArea;
104 }
105
106 void HTMLTextAreaElement::didAddUserAgentShadowRoot(ShadowRoot& root)
107 {
108     root.appendChild(TextControlInnerTextElement::create(document()));
109     updateInnerTextElementEditability();
110 }
111
112 const AtomicString& HTMLTextAreaElement::formControlType() const
113 {
114     static NeverDestroyed<const AtomicString> textarea("textarea", AtomicString::ConstructFromLiteral);
115     return textarea;
116 }
117
118 FormControlState HTMLTextAreaElement::saveFormControlState() const
119 {
120     return m_isDirty ? FormControlState { { value() } } : FormControlState { };
121 }
122
123 void HTMLTextAreaElement::restoreFormControlState(const FormControlState& state)
124 {
125     setValue(state[0]);
126 }
127
128 void HTMLTextAreaElement::childrenChanged(const ChildChange& change)
129 {
130     HTMLElement::childrenChanged(change);
131     setLastChangeWasNotUserEdit();
132     if (m_isDirty)
133         setInnerTextValue(value());
134     else
135         setNonDirtyValue(defaultValue());
136 }
137
138 bool HTMLTextAreaElement::isPresentationAttribute(const QualifiedName& name) const
139 {
140     if (name == alignAttr) {
141         // Don't map 'align' attribute.  This matches what Firefox, Opera and IE do.
142         // See http://bugs.webkit.org/show_bug.cgi?id=7075
143         return false;
144     }
145
146     if (name == wrapAttr)
147         return true;
148     return HTMLTextFormControlElement::isPresentationAttribute(name);
149 }
150
151 void HTMLTextAreaElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
152 {
153     if (name == wrapAttr) {
154         if (shouldWrapText()) {
155             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePreWrap);
156             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
157         } else {
158             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePre);
159             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueNormal);
160         }
161     } else
162         HTMLTextFormControlElement::collectStyleForPresentationAttribute(name, value, style);
163 }
164
165 void HTMLTextAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
166 {
167     if (name == rowsAttr) {
168         unsigned rows = limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(value, defaultRows);
169         if (m_rows != rows) {
170             m_rows = rows;
171             if (renderer())
172                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
173         }
174     } else if (name == colsAttr) {
175         unsigned cols = limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(value, defaultCols);
176         if (m_cols != cols) {
177             m_cols = cols;
178             if (renderer())
179                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
180         }
181     } else if (name == wrapAttr) {
182         // The virtual/physical values were a Netscape extension of HTML 3.0, now deprecated.
183         // The soft/hard /off values are a recommendation for HTML 4 extension by IE and NS 4.
184         WrapMethod wrap;
185         if (equalLettersIgnoringASCIICase(value, "physical") || equalLettersIgnoringASCIICase(value, "hard") || equalLettersIgnoringASCIICase(value, "on"))
186             wrap = HardWrap;
187         else if (equalLettersIgnoringASCIICase(value, "off"))
188             wrap = NoWrap;
189         else
190             wrap = SoftWrap;
191         if (wrap != m_wrap) {
192             m_wrap = wrap;
193             if (renderer())
194                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
195         }
196     } else if (name == maxlengthAttr)
197         maxLengthAttributeChanged(value);
198     else if (name == minlengthAttr)
199         minLengthAttributeChanged(value);
200     else
201         HTMLTextFormControlElement::parseAttribute(name, value);
202 }
203
204 void HTMLTextAreaElement::maxLengthAttributeChanged(const AtomicString& newValue)
205 {
206     internalSetMaxLength(parseHTMLNonNegativeInteger(newValue).value_or(-1));
207     updateValidity();
208 }
209
210 void HTMLTextAreaElement::minLengthAttributeChanged(const AtomicString& newValue)
211 {
212     internalSetMinLength(parseHTMLNonNegativeInteger(newValue).value_or(-1));
213     updateValidity();
214 }
215
216 RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
217 {
218     return createRenderer<RenderTextControlMultiLine>(*this, WTFMove(style));
219 }
220
221 bool HTMLTextAreaElement::appendFormData(DOMFormData& formData, bool)
222 {
223     if (name().isEmpty())
224         return false;
225
226     Ref<HTMLTextAreaElement> protectedThis(*this);
227     document().updateLayout();
228
229     formData.append(name(), m_wrap == HardWrap ? valueWithHardLineBreaks() : value());
230
231     auto& dirnameAttrValue = attributeWithoutSynchronization(dirnameAttr);
232     if (!dirnameAttrValue.isNull())
233         formData.append(dirnameAttrValue, directionForFormData());
234
235     return true;    
236 }
237
238 void HTMLTextAreaElement::reset()
239 {
240     setNonDirtyValue(defaultValue());
241 }
242
243 bool HTMLTextAreaElement::hasCustomFocusLogic() const
244 {
245     return true;
246 }
247
248 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
249 {
250     // If a given text area can be focused at all, then it will always be keyboard focusable.
251     return isFocusable();
252 }
253
254 bool HTMLTextAreaElement::isMouseFocusable() const
255 {
256     return isFocusable();
257 }
258
259 void HTMLTextAreaElement::updateFocusAppearance(SelectionRestorationMode restorationMode, SelectionRevealMode revealMode)
260 {
261     if (restorationMode == SelectionRestorationMode::SetDefault || !hasCachedSelection()) {
262         // If this is the first focus, set a caret at the beginning of the text.  
263         // This matches some browsers' behavior; see bug 11746 Comment #15.
264         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
265         setSelectionRange(0, 0, SelectionHasNoDirection, revealMode, Element::defaultFocusTextStateChangeIntent());
266     } else
267         restoreCachedSelection(revealMode, Element::defaultFocusTextStateChangeIntent());
268 }
269
270 void HTMLTextAreaElement::defaultEventHandler(Event& event)
271 {
272     if (renderer() && (event.isMouseEvent() || event.type() == eventNames().blurEvent))
273         forwardEvent(event);
274     else if (renderer() && is<BeforeTextInsertedEvent>(event))
275         handleBeforeTextInsertedEvent(downcast<BeforeTextInsertedEvent>(event));
276
277     HTMLTextFormControlElement::defaultEventHandler(event);
278 }
279
280 void HTMLTextAreaElement::subtreeHasChanged()
281 {
282     setChangedSinceLastFormControlChangeEvent(true);
283     setFormControlValueMatchesRenderer(false);
284     updateValidity();
285
286     if (!focused())
287         return;
288
289     if (RefPtr<Frame> frame = document().frame())
290         frame->editor().textDidChangeInTextArea(this);
291     // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check.
292     calculateAndAdjustDirectionality();
293 }
294
295 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent& event) const
296 {
297     ASSERT(renderer());
298     int signedMaxLength = effectiveMaxLength();
299     if (signedMaxLength < 0)
300         return;
301     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
302
303     const String& currentValue = innerTextValue();
304     unsigned numberOfLineBreaksInCurrentValue = numberOfLineBreaks(currentValue);
305     if (upperBoundForLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue)
306         + upperBoundForLengthForSubmission(event.text(), numberOfLineBreaks(event.text())) < unsignedMaxLength)
307         return;
308
309     unsigned currentLength = computeLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue);
310     // selectionLength represents the selection length of this text field to be
311     // removed by this insertion.
312     // If the text field has no focus, we don't need to take account of the
313     // selection length. The selection is the source of text drag-and-drop in
314     // that case, and nothing in the text field will be removed.
315     unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document().frame()->selection().selection().toNormalizedRange().get())) : 0;
316     ASSERT(currentLength >= selectionLength);
317     unsigned baseLength = currentLength - selectionLength;
318     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
319     event.setText(sanitizeUserInputValue(event.text(), appendableLength));
320 }
321
322 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
323 {
324     return proposedValue.left(numCodeUnitsInGraphemeClusters(proposedValue, maxLength));
325 }
326
327 RefPtr<TextControlInnerTextElement> HTMLTextAreaElement::innerTextElement() const
328 {
329     RefPtr<ShadowRoot> root = userAgentShadowRoot();
330     if (!root)
331         return nullptr;
332     
333     return childrenOfType<TextControlInnerTextElement>(*root).first();
334 }
335
336 void HTMLTextAreaElement::rendererWillBeDestroyed()
337 {
338     updateValue();
339 }
340
341 void HTMLTextAreaElement::updateValue() const
342 {
343     if (formControlValueMatchesRenderer())
344         return;
345
346     ASSERT(renderer());
347     m_value = innerTextValue();
348     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
349     m_isDirty = true;
350     m_wasModifiedByUser = true;
351     const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility();
352 }
353
354 String HTMLTextAreaElement::value() const
355 {
356     updateValue();
357     return m_value;
358 }
359
360 void HTMLTextAreaElement::setValue(const String& value)
361 {
362     setValueCommon(value);
363     m_isDirty = true;
364     updateValidity();
365 }
366
367 void HTMLTextAreaElement::setNonDirtyValue(const String& value)
368 {
369     setValueCommon(value);
370     m_isDirty = false;
371     updateValidity();
372 }
373
374 void HTMLTextAreaElement::setValueCommon(const String& newValue)
375 {
376     m_wasModifiedByUser = false;
377     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
378     // We normalize line endings coming from JavaScript here.
379     String normalizedValue = newValue.isNull() ? emptyString() : newValue;
380     normalizedValue.replace("\r\n", "\n");
381     normalizedValue.replace('\r', '\n');
382
383     // Return early because we don't want to move the caret or trigger other side effects
384     // when the value isn't changing. This matches Firefox behavior, at least.
385     if (normalizedValue == value())
386         return;
387
388     m_value = normalizedValue;
389     setInnerTextValue(m_value);
390     setLastChangeWasNotUserEdit();
391     updatePlaceholderVisibility();
392     invalidateStyleForSubtree();
393     setFormControlValueMatchesRenderer(true);
394
395     // Set the caret to the end of the text value.
396     if (document().focusedElement() == this) {
397         unsigned endOfString = m_value.length();
398         setSelectionRange(endOfString, endOfString);
399     }
400
401     setTextAsOfLastFormControlChangeEvent(normalizedValue);
402 }
403
404 String HTMLTextAreaElement::defaultValue() const
405 {
406     return TextNodeTraversal::childTextContent(*this);
407 }
408
409 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
410 {
411     setTextContent(defaultValue);
412 }
413
414 String HTMLTextAreaElement::validationMessage() const
415 {
416     if (!willValidate())
417         return String();
418
419     if (customError())
420         return customValidationMessage();
421
422     if (valueMissing())
423         return validationMessageValueMissingText();
424
425     if (tooShort())
426         return validationMessageTooShortText(computeLengthForSubmission(value()), minLength());
427
428     if (tooLong())
429         return validationMessageTooLongText(computeLengthForSubmission(value()), effectiveMaxLength());
430
431     return String();
432 }
433
434 bool HTMLTextAreaElement::valueMissing() const
435 {
436     return willValidate() && valueMissing(value());
437 }
438
439 bool HTMLTextAreaElement::tooShort() const
440 {
441     return willValidate() && tooShort(value(), CheckDirtyFlag);
442 }
443
444 bool HTMLTextAreaElement::tooShort(StringView value, NeedsToCheckDirtyFlag check) const
445 {
446     // Return false for the default value or value set by script even if it is
447     // shorter than minLength.
448     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
449         return false;
450
451     int min = minLength();
452     if (min <= 0)
453         return false;
454
455     // The empty string is excluded from tooShort validation.
456     if (value.isEmpty())
457         return false;
458
459     // FIXME: The HTML specification says that the "number of characters" is measured using code-unit length and,
460     // in the case of textarea elements, with all line breaks normalized to a single character (as opposed to CRLF pairs).
461     unsigned unsignedMin = static_cast<unsigned>(min);
462     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
463     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) < unsignedMin
464         && computeLengthForSubmission(value, numberOfLineBreaksInValue) < unsignedMin;
465 }
466
467 bool HTMLTextAreaElement::tooLong() const
468 {
469     return willValidate() && tooLong(value(), CheckDirtyFlag);
470 }
471
472 bool HTMLTextAreaElement::tooLong(StringView value, NeedsToCheckDirtyFlag check) const
473 {
474     // Return false for the default value or value set by script even if it is
475     // longer than maxLength.
476     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
477         return false;
478
479     int max = effectiveMaxLength();
480     if (max < 0)
481         return false;
482
483     // FIXME: The HTML specification says that the "number of characters" is measured using code-unit length and,
484     // in the case of textarea elements, with all line breaks normalized to a single character (as opposed to CRLF pairs).
485     unsigned unsignedMax = static_cast<unsigned>(max);
486     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
487     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax
488         && computeLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax;
489 }
490
491 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
492 {
493     return !valueMissing(candidate) && !tooShort(candidate, IgnoreDirtyFlag) && !tooLong(candidate, IgnoreDirtyFlag);
494 }
495
496 void HTMLTextAreaElement::accessKeyAction(bool)
497 {
498     focus();
499 }
500
501 void HTMLTextAreaElement::setCols(unsigned cols)
502 {
503     setUnsignedIntegralAttribute(colsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(cols, defaultCols));
504 }
505
506 void HTMLTextAreaElement::setRows(unsigned rows)
507 {
508     setUnsignedIntegralAttribute(rowsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(rows, defaultRows));
509 }
510
511 bool HTMLTextAreaElement::shouldUseInputMethod()
512 {
513     return true;
514 }
515
516 HTMLElement* HTMLTextAreaElement::placeholderElement() const
517 {
518     return m_placeholder.get();
519 }
520
521 bool HTMLTextAreaElement::matchesReadWritePseudoClass() const
522 {
523     return !isDisabledOrReadOnly();
524 }
525
526 void HTMLTextAreaElement::updatePlaceholderText()
527 {
528     String placeholderText = strippedPlaceholder();
529     if (placeholderText.isEmpty()) {
530         if (m_placeholder) {
531             userAgentShadowRoot()->removeChild(*m_placeholder);
532             m_placeholder = nullptr;
533         }
534         return;
535     }
536     if (!m_placeholder) {
537         m_placeholder = TextControlPlaceholderElement::create(document());
538         userAgentShadowRoot()->insertBefore(*m_placeholder, innerTextElement()->nextSibling());
539     }
540     m_placeholder->setInnerText(placeholderText);
541 }
542
543 bool HTMLTextAreaElement::willRespondToMouseClickEvents()
544 {
545     return !isDisabledFormControl();
546 }
547
548 RenderStyle HTMLTextAreaElement::createInnerTextStyle(const RenderStyle& style)
549 {
550     auto textBlockStyle = RenderStyle::create();
551     textBlockStyle.inheritFrom(style);
552     adjustInnerTextStyle(style, textBlockStyle);
553     textBlockStyle.setDisplay(DisplayType::Block);
554     return textBlockStyle;
555 }
556
557 void HTMLTextAreaElement::copyNonAttributePropertiesFromElement(const Element& source)
558 {
559     auto& sourceElement = downcast<HTMLTextAreaElement>(source);
560
561     setValueCommon(sourceElement.value());
562     m_isDirty = sourceElement.m_isDirty;
563     HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(source);
564
565     updateValidity();
566 }
567
568 } // namespace WebCore