Throw the right exception upon memory exhaustion in Array::slice
[WebKit.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 AtomString& HTMLTextAreaElement::formControlType() const
113 {
114     static NeverDestroyed<const AtomString> textarea("textarea", AtomString::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 AtomString& 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 AtomString& 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 AtomString& newValue)
205 {
206     internalSetMaxLength(parseHTMLNonNegativeInteger(newValue).value_or(-1));
207     updateValidity();
208 }
209
210 void HTMLTextAreaElement::minLengthAttributeChanged(const AtomString& 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 int HTMLTextAreaElement::defaultTabIndex() const
249 {
250     return 0;
251 }
252
253 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
254 {
255     // If a given text area can be focused at all, then it will always be keyboard focusable.
256     return isFocusable();
257 }
258
259 bool HTMLTextAreaElement::isMouseFocusable() const
260 {
261     return isFocusable();
262 }
263
264 void HTMLTextAreaElement::updateFocusAppearance(SelectionRestorationMode restorationMode, SelectionRevealMode revealMode)
265 {
266     if (restorationMode == SelectionRestorationMode::SetDefault || !hasCachedSelection()) {
267         // If this is the first focus, set a caret at the beginning of the text.  
268         // This matches some browsers' behavior; see bug 11746 Comment #15.
269         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
270         setSelectionRange(0, 0, SelectionHasNoDirection, revealMode, Element::defaultFocusTextStateChangeIntent());
271     } else
272         restoreCachedSelection(revealMode, Element::defaultFocusTextStateChangeIntent());
273 }
274
275 void HTMLTextAreaElement::defaultEventHandler(Event& event)
276 {
277     if (renderer() && (event.isMouseEvent() || event.type() == eventNames().blurEvent))
278         forwardEvent(event);
279     else if (renderer() && is<BeforeTextInsertedEvent>(event))
280         handleBeforeTextInsertedEvent(downcast<BeforeTextInsertedEvent>(event));
281
282     HTMLTextFormControlElement::defaultEventHandler(event);
283 }
284
285 void HTMLTextAreaElement::subtreeHasChanged()
286 {
287     setChangedSinceLastFormControlChangeEvent(true);
288     setFormControlValueMatchesRenderer(false);
289     updateValidity();
290
291     if (!focused())
292         return;
293
294     if (RefPtr<Frame> frame = document().frame())
295         frame->editor().textDidChangeInTextArea(this);
296     // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check.
297     calculateAndAdjustDirectionality();
298 }
299
300 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent& event) const
301 {
302     ASSERT(renderer());
303     int signedMaxLength = effectiveMaxLength();
304     if (signedMaxLength < 0)
305         return;
306     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
307
308     const String& currentValue = innerTextValue();
309     unsigned numberOfLineBreaksInCurrentValue = numberOfLineBreaks(currentValue);
310     if (upperBoundForLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue)
311         + upperBoundForLengthForSubmission(event.text(), numberOfLineBreaks(event.text())) < unsignedMaxLength)
312         return;
313
314     unsigned currentLength = computeLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue);
315     // selectionLength represents the selection length of this text field to be
316     // removed by this insertion.
317     // If the text field has no focus, we don't need to take account of the
318     // selection length. The selection is the source of text drag-and-drop in
319     // that case, and nothing in the text field will be removed.
320     unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document().frame()->selection().selection().toNormalizedRange().get())) : 0;
321     ASSERT(currentLength >= selectionLength);
322     unsigned baseLength = currentLength - selectionLength;
323     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
324     event.setText(sanitizeUserInputValue(event.text(), appendableLength));
325 }
326
327 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
328 {
329     return proposedValue.left(numCodeUnitsInGraphemeClusters(proposedValue, maxLength));
330 }
331
332 RefPtr<TextControlInnerTextElement> HTMLTextAreaElement::innerTextElement() const
333 {
334     RefPtr<ShadowRoot> root = userAgentShadowRoot();
335     if (!root)
336         return nullptr;
337     
338     return childrenOfType<TextControlInnerTextElement>(*root).first();
339 }
340
341 void HTMLTextAreaElement::rendererWillBeDestroyed()
342 {
343     updateValue();
344 }
345
346 void HTMLTextAreaElement::updateValue() const
347 {
348     if (formControlValueMatchesRenderer())
349         return;
350
351     ASSERT(renderer());
352     m_value = innerTextValue();
353     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
354     m_isDirty = true;
355     m_wasModifiedByUser = true;
356     const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility();
357 }
358
359 String HTMLTextAreaElement::value() const
360 {
361     updateValue();
362     return m_value;
363 }
364
365 void HTMLTextAreaElement::setValue(const String& value)
366 {
367     setValueCommon(value);
368     m_isDirty = true;
369     updateValidity();
370 }
371
372 void HTMLTextAreaElement::setNonDirtyValue(const String& value)
373 {
374     setValueCommon(value);
375     m_isDirty = false;
376     updateValidity();
377 }
378
379 void HTMLTextAreaElement::setValueCommon(const String& newValue)
380 {
381     m_wasModifiedByUser = false;
382     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
383     // We normalize line endings coming from JavaScript here.
384     String normalizedValue = newValue.isNull() ? emptyString() : newValue;
385     normalizedValue.replace("\r\n", "\n");
386     normalizedValue.replace('\r', '\n');
387
388     // Return early because we don't want to move the caret or trigger other side effects
389     // when the value isn't changing. This matches Firefox behavior, at least.
390     if (normalizedValue == value())
391         return;
392
393     m_value = normalizedValue;
394     setInnerTextValue(m_value);
395     setLastChangeWasNotUserEdit();
396     updatePlaceholderVisibility();
397     invalidateStyleForSubtree();
398     setFormControlValueMatchesRenderer(true);
399
400     // Set the caret to the end of the text value.
401     if (document().focusedElement() == this) {
402         unsigned endOfString = m_value.length();
403         setSelectionRange(endOfString, endOfString);
404     }
405
406     setTextAsOfLastFormControlChangeEvent(normalizedValue);
407 }
408
409 String HTMLTextAreaElement::defaultValue() const
410 {
411     return TextNodeTraversal::childTextContent(*this);
412 }
413
414 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
415 {
416     setTextContent(defaultValue);
417 }
418
419 String HTMLTextAreaElement::validationMessage() const
420 {
421     if (!willValidate())
422         return String();
423
424     if (customError())
425         return customValidationMessage();
426
427     if (valueMissing())
428         return validationMessageValueMissingText();
429
430     if (tooShort())
431         return validationMessageTooShortText(computeLengthForSubmission(value()), minLength());
432
433     if (tooLong())
434         return validationMessageTooLongText(computeLengthForSubmission(value()), effectiveMaxLength());
435
436     return String();
437 }
438
439 bool HTMLTextAreaElement::valueMissing() const
440 {
441     return willValidate() && valueMissing(value());
442 }
443
444 bool HTMLTextAreaElement::tooShort() const
445 {
446     return willValidate() && tooShort(value(), CheckDirtyFlag);
447 }
448
449 bool HTMLTextAreaElement::tooShort(StringView value, NeedsToCheckDirtyFlag check) const
450 {
451     // Return false for the default value or value set by script even if it is
452     // shorter than minLength.
453     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
454         return false;
455
456     int min = minLength();
457     if (min <= 0)
458         return false;
459
460     // The empty string is excluded from tooShort validation.
461     if (value.isEmpty())
462         return false;
463
464     // FIXME: The HTML specification says that the "number of characters" is measured using code-unit length and,
465     // in the case of textarea elements, with all line breaks normalized to a single character (as opposed to CRLF pairs).
466     unsigned unsignedMin = static_cast<unsigned>(min);
467     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
468     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) < unsignedMin
469         && computeLengthForSubmission(value, numberOfLineBreaksInValue) < unsignedMin;
470 }
471
472 bool HTMLTextAreaElement::tooLong() const
473 {
474     return willValidate() && tooLong(value(), CheckDirtyFlag);
475 }
476
477 bool HTMLTextAreaElement::tooLong(StringView value, NeedsToCheckDirtyFlag check) const
478 {
479     // Return false for the default value or value set by script even if it is
480     // longer than maxLength.
481     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
482         return false;
483
484     int max = effectiveMaxLength();
485     if (max < 0)
486         return false;
487
488     // FIXME: The HTML specification says that the "number of characters" is measured using code-unit length and,
489     // in the case of textarea elements, with all line breaks normalized to a single character (as opposed to CRLF pairs).
490     unsigned unsignedMax = static_cast<unsigned>(max);
491     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
492     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax
493         && computeLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax;
494 }
495
496 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
497 {
498     return !valueMissing(candidate) && !tooShort(candidate, IgnoreDirtyFlag) && !tooLong(candidate, IgnoreDirtyFlag);
499 }
500
501 void HTMLTextAreaElement::accessKeyAction(bool)
502 {
503     focus();
504 }
505
506 void HTMLTextAreaElement::setCols(unsigned cols)
507 {
508     setUnsignedIntegralAttribute(colsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(cols, defaultCols));
509 }
510
511 void HTMLTextAreaElement::setRows(unsigned rows)
512 {
513     setUnsignedIntegralAttribute(rowsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(rows, defaultRows));
514 }
515
516 bool HTMLTextAreaElement::shouldUseInputMethod()
517 {
518     return true;
519 }
520
521 HTMLElement* HTMLTextAreaElement::placeholderElement() const
522 {
523     return m_placeholder.get();
524 }
525
526 bool HTMLTextAreaElement::matchesReadWritePseudoClass() const
527 {
528     return !isDisabledOrReadOnly();
529 }
530
531 void HTMLTextAreaElement::updatePlaceholderText()
532 {
533     String placeholderText = strippedPlaceholder();
534     if (placeholderText.isEmpty()) {
535         if (m_placeholder) {
536             userAgentShadowRoot()->removeChild(*m_placeholder);
537             m_placeholder = nullptr;
538         }
539         return;
540     }
541     if (!m_placeholder) {
542         m_placeholder = TextControlPlaceholderElement::create(document());
543         userAgentShadowRoot()->insertBefore(*m_placeholder, innerTextElement()->nextSibling());
544     }
545     m_placeholder->setInnerText(placeholderText);
546 }
547
548 bool HTMLTextAreaElement::willRespondToMouseClickEvents()
549 {
550     return !isDisabledFormControl();
551 }
552
553 RenderStyle HTMLTextAreaElement::createInnerTextStyle(const RenderStyle& style)
554 {
555     auto textBlockStyle = RenderStyle::create();
556     textBlockStyle.inheritFrom(style);
557     adjustInnerTextStyle(style, textBlockStyle);
558     textBlockStyle.setDisplay(DisplayType::Block);
559     return textBlockStyle;
560 }
561
562 void HTMLTextAreaElement::copyNonAttributePropertiesFromElement(const Element& source)
563 {
564     auto& sourceElement = downcast<HTMLTextAreaElement>(source);
565
566     setValueCommon(sourceElement.value());
567     m_isDirty = sourceElement.m_isDirty;
568     HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(source);
569
570     updateValidity();
571 }
572
573 } // namespace WebCore