3a0a9db29ba31b77b880a5677b2e1bdcc4ea4091
[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, 2005, 2006, 2007, 2008, 2010, 2014 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 "Document.h"
32 #include "Editor.h"
33 #include "Event.h"
34 #include "EventHandler.h"
35 #include "EventNames.h"
36 #include "ExceptionCode.h"
37 #include "ExceptionCodePlaceholder.h"
38 #include "FormController.h"
39 #include "FormDataList.h"
40 #include "Frame.h"
41 #include "FrameSelection.h"
42 #include "HTMLNames.h"
43 #include "HTMLParserIdioms.h"
44 #include "LocalizedStrings.h"
45 #include "RenderTextControlMultiLine.h"
46 #include "ShadowRoot.h"
47 #include "Text.h"
48 #include <wtf/text/TextBreakIterator.h>
49 #include "TextControlInnerElements.h"
50 #include "TextIterator.h"
51 #include "TextNodeTraversal.h"
52 #include <wtf/Ref.h>
53 #include <wtf/StdLibExtras.h>
54
55 namespace WebCore {
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(const String& text, unsigned numberOfLineBreaks)
65 {
66     return numGraphemeClusters(text) + numberOfLineBreaks;
67 }
68
69 static unsigned numberOfLineBreaks(const String& 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(const String& text)
81 {
82     return numGraphemeClusters(text) + numberOfLineBreaks(text);
83 }
84
85 static inline unsigned upperBoundForLengthForSubmission(const String& 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     Ref<HTMLTextAreaElement> 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()), ASSERT_NO_EXCEPTION);
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 == accesskeyAttr) {
197         // ignore for the moment
198     } else if (name == maxlengthAttr)
199         maxLengthAttributeChanged(value);
200     else
201         HTMLTextFormControlElement::parseAttribute(name, value);
202 }
203
204 void HTMLTextAreaElement::maxLengthAttributeChanged(const AtomicString& newValue)
205 {
206     m_maxLength = parseHTMLNonNegativeInteger(newValue).valueOr(-1);
207     updateValidity();
208 }
209
210 RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
211 {
212     return createRenderer<RenderTextControlMultiLine>(*this, WTFMove(style));
213 }
214
215 bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
216 {
217     if (name().isEmpty())
218         return false;
219
220     document().updateLayout();
221
222     const String& text = (m_wrap == HardWrap) ? valueWithHardLineBreaks() : value();
223     encoding.appendData(name(), text);
224
225     const AtomicString& dirnameAttrValue = attributeWithoutSynchronization(dirnameAttr);
226     if (!dirnameAttrValue.isNull())
227         encoding.appendData(dirnameAttrValue, directionForFormData());
228     return true;    
229 }
230
231 void HTMLTextAreaElement::reset()
232 {
233     setNonDirtyValue(defaultValue());
234 }
235
236 bool HTMLTextAreaElement::hasCustomFocusLogic() const
237 {
238     return true;
239 }
240
241 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
242 {
243     // If a given text area can be focused at all, then it will always be keyboard focusable.
244     return isFocusable();
245 }
246
247 bool HTMLTextAreaElement::isMouseFocusable() const
248 {
249     return isFocusable();
250 }
251
252 void HTMLTextAreaElement::updateFocusAppearance(SelectionRestorationMode restorationMode, SelectionRevealMode revealMode)
253 {
254     if (restorationMode == SelectionRestorationMode::SetDefault || !hasCachedSelection()) {
255         // If this is the first focus, set a caret at the beginning of the text.  
256         // This matches some browsers' behavior; see bug 11746 Comment #15.
257         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
258         setSelectionRange(0, 0, SelectionHasNoDirection, Element::defaultFocusTextStateChangeIntent());
259     } else
260         restoreCachedSelection(Element::defaultFocusTextStateChangeIntent());
261
262     if (document().frame())
263         document().frame()->selection().revealSelection(revealMode);
264 }
265
266 void HTMLTextAreaElement::defaultEventHandler(Event* event)
267 {
268     if (renderer() && (event->isMouseEvent() || event->type() == eventNames().blurEvent))
269         forwardEvent(event);
270     else if (renderer() && is<BeforeTextInsertedEvent>(*event))
271         handleBeforeTextInsertedEvent(downcast<BeforeTextInsertedEvent>(event));
272
273     HTMLTextFormControlElement::defaultEventHandler(event);
274 }
275
276 void HTMLTextAreaElement::subtreeHasChanged()
277 {
278     setChangedSinceLastFormControlChangeEvent(true);
279     setFormControlValueMatchesRenderer(false);
280     updateValidity();
281
282     if (!focused())
283         return;
284
285     if (Frame* frame = document().frame())
286         frame->editor().textDidChangeInTextArea(this);
287     // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check.
288     calculateAndAdjustDirectionality();
289 }
290
291 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event) const
292 {
293     ASSERT(event);
294     ASSERT(renderer());
295     int signedMaxLength = effectiveMaxLength();
296     if (signedMaxLength < 0)
297         return;
298     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
299
300     const String& currentValue = innerTextValue();
301     unsigned numberOfLineBreaksInCurrentValue = numberOfLineBreaks(currentValue);
302     if (upperBoundForLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue)
303         + upperBoundForLengthForSubmission(event->text(), numberOfLineBreaks(event->text())) < unsignedMaxLength)
304         return;
305
306     unsigned currentLength = computeLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue);
307     // selectionLength represents the selection length of this text field to be
308     // removed by this insertion.
309     // If the text field has no focus, we don't need to take account of the
310     // selection length. The selection is the source of text drag-and-drop in
311     // that case, and nothing in the text field will be removed.
312     unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document().frame()->selection().selection().toNormalizedRange().get())) : 0;
313     ASSERT(currentLength >= selectionLength);
314     unsigned baseLength = currentLength - selectionLength;
315     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
316     event->setText(sanitizeUserInputValue(event->text(), appendableLength));
317 }
318
319 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
320 {
321     return proposedValue.left(numCharactersInGraphemeClusters(proposedValue, maxLength));
322 }
323
324 TextControlInnerTextElement* HTMLTextAreaElement::innerTextElement() const
325 {
326     return downcast<TextControlInnerTextElement>(userAgentShadowRoot()->firstChild());
327 }
328
329 void HTMLTextAreaElement::rendererWillBeDestroyed()
330 {
331     updateValue();
332 }
333
334 void HTMLTextAreaElement::updateValue() const
335 {
336     if (formControlValueMatchesRenderer())
337         return;
338
339     ASSERT(renderer());
340     m_value = innerTextValue();
341     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
342     m_isDirty = true;
343     m_wasModifiedByUser = true;
344     const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility();
345 }
346
347 String HTMLTextAreaElement::value() const
348 {
349     updateValue();
350     return m_value;
351 }
352
353 void HTMLTextAreaElement::setValue(const String& value)
354 {
355     setValueCommon(value);
356     m_isDirty = true;
357     updateValidity();
358 }
359
360 void HTMLTextAreaElement::setNonDirtyValue(const String& value)
361 {
362     setValueCommon(value);
363     m_isDirty = false;
364     updateValidity();
365 }
366
367 void HTMLTextAreaElement::setValueCommon(const String& newValue)
368 {
369     m_wasModifiedByUser = false;
370     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
371     // We normalize line endings coming from JavaScript here.
372     String normalizedValue = newValue.isNull() ? emptyString() : newValue;
373     normalizedValue.replace("\r\n", "\n");
374     normalizedValue.replace('\r', '\n');
375
376     // Return early because we don't want to move the caret or trigger other side effects
377     // when the value isn't changing. This matches Firefox behavior, at least.
378     if (normalizedValue == value())
379         return;
380
381     m_value = normalizedValue;
382     setInnerTextValue(m_value);
383     setLastChangeWasNotUserEdit();
384     updatePlaceholderVisibility();
385     setNeedsStyleRecalc();
386     setFormControlValueMatchesRenderer(true);
387
388     // Set the caret to the end of the text value.
389     if (document().focusedElement() == this) {
390         unsigned endOfString = m_value.length();
391         setSelectionRange(endOfString, endOfString);
392     }
393
394     setTextAsOfLastFormControlChangeEvent(normalizedValue);
395 }
396
397 String HTMLTextAreaElement::defaultValue() const
398 {
399     return TextNodeTraversal::contentsAsString(*this);
400 }
401
402 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
403 {
404     Ref<HTMLTextAreaElement> protectedThis(*this);
405
406     // To preserve comments, remove only the text nodes, then add a single text node.
407     Vector<Ref<Text>> textNodes;
408     for (Text* textNode = TextNodeTraversal::firstChild(*this); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
409         textNodes.append(*textNode);
410
411     for (auto& textNode : textNodes)
412         removeChild(textNode.get(), IGNORE_EXCEPTION);
413
414     // Normalize line endings.
415     String value = defaultValue;
416     value.replace("\r\n", "\n");
417     value.replace('\r', '\n');
418
419     insertBefore(document().createTextNode(value), firstChild(), IGNORE_EXCEPTION);
420
421     if (!m_isDirty)
422         setNonDirtyValue(value);
423 }
424
425 String HTMLTextAreaElement::validationMessage() const
426 {
427     if (!willValidate())
428         return String();
429
430     if (customError())
431         return customValidationMessage();
432
433     if (valueMissing())
434         return validationMessageValueMissingText();
435
436     if (tooLong())
437         return validationMessageTooLongText(computeLengthForSubmission(value()), effectiveMaxLength());
438
439     return String();
440 }
441
442 bool HTMLTextAreaElement::valueMissing() const
443 {
444     return willValidate() && valueMissing(value());
445 }
446
447 bool HTMLTextAreaElement::tooLong() const
448 {
449     return willValidate() && tooLong(value(), CheckDirtyFlag);
450 }
451
452 bool HTMLTextAreaElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const
453 {
454     // Return false for the default value or value set by script even if it is
455     // longer than maxLength.
456     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
457         return false;
458
459     int max = effectiveMaxLength();
460     if (max < 0)
461         return false;
462     unsigned unsignedMax = static_cast<unsigned>(max);
463     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
464     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax
465         && computeLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax;
466 }
467
468 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
469 {
470     return !valueMissing(candidate) && !tooLong(candidate, IgnoreDirtyFlag);
471 }
472
473 void HTMLTextAreaElement::accessKeyAction(bool)
474 {
475     focus();
476 }
477
478 void HTMLTextAreaElement::setCols(unsigned cols)
479 {
480     setUnsignedIntegralAttribute(colsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(cols, defaultCols));
481 }
482
483 void HTMLTextAreaElement::setRows(unsigned rows)
484 {
485     setUnsignedIntegralAttribute(rowsAttr, limitToOnlyHTMLNonNegativeNumbersGreaterThanZero(rows, defaultRows));
486 }
487
488 bool HTMLTextAreaElement::shouldUseInputMethod()
489 {
490     return true;
491 }
492
493 HTMLElement* HTMLTextAreaElement::placeholderElement() const
494 {
495     return m_placeholder.get();
496 }
497
498 bool HTMLTextAreaElement::matchesReadWritePseudoClass() const
499 {
500     return !isDisabledOrReadOnly();
501 }
502
503 void HTMLTextAreaElement::updatePlaceholderText()
504 {
505     String placeholderText = strippedPlaceholder();
506     if (placeholderText.isEmpty()) {
507         if (m_placeholder) {
508             userAgentShadowRoot()->removeChild(*m_placeholder, ASSERT_NO_EXCEPTION);
509             m_placeholder = nullptr;
510         }
511         return;
512     }
513     if (!m_placeholder) {
514         m_placeholder = TextControlPlaceholderElement::create(document());
515         userAgentShadowRoot()->insertBefore(*m_placeholder, innerTextElement()->nextSibling());
516     }
517     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
518 }
519
520 bool HTMLTextAreaElement::willRespondToMouseClickEvents()
521 {
522     return !isDisabledFormControl();
523 }
524
525 RenderStyle HTMLTextAreaElement::createInnerTextStyle(const RenderStyle& style) const
526 {
527     auto textBlockStyle = RenderStyle::create();
528     textBlockStyle.inheritFrom(&style);
529     adjustInnerTextStyle(style, textBlockStyle);
530     textBlockStyle.setDisplay(BLOCK);
531
532 #if PLATFORM(IOS)
533     // We're adding three extra pixels of padding to line textareas up with text fields.  
534     textBlockStyle.setPaddingLeft(Length(3, Fixed));
535     textBlockStyle.setPaddingRight(Length(3, Fixed));
536 #endif
537
538     return textBlockStyle;
539 }
540
541 } // namespace WebCore