Node.appendChild(null) / replaceChild(null, null) / removeChild(null) / insertBefore...
[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 "LocalizedStrings.h"
44 #include "RenderTextControlMultiLine.h"
45 #include "ShadowRoot.h"
46 #include "Text.h"
47 #include "TextBreakIterator.h"
48 #include "TextControlInnerElements.h"
49 #include "TextIterator.h"
50 #include "TextNodeTraversal.h"
51 #include <wtf/Ref.h>
52 #include <wtf/StdLibExtras.h>
53 #include <wtf/text/StringBuilder.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     , m_wrap(SoftWrap)
95     , m_placeholder(0)
96     , m_isDirty(false)
97     , m_wasModifiedByUser(false)
98 {
99     ASSERT(hasTagName(textareaTag));
100     setFormControlValueMatchesRenderer(true);
101 }
102
103 Ref<HTMLTextAreaElement> HTMLTextAreaElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
104 {
105     Ref<HTMLTextAreaElement> textArea = adoptRef(*new HTMLTextAreaElement(tagName, document, form));
106     textArea->ensureUserAgentShadowRoot();
107     return textArea;
108 }
109
110 void HTMLTextAreaElement::didAddUserAgentShadowRoot(ShadowRoot* root)
111 {
112     root->appendChild(TextControlInnerTextElement::create(document()), ASSERT_NO_EXCEPTION);
113     updateInnerTextElementEditability();
114 }
115
116 const AtomicString& HTMLTextAreaElement::formControlType() const
117 {
118     DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, textarea, ("textarea", AtomicString::ConstructFromLiteral));
119     return textarea;
120 }
121
122 FormControlState HTMLTextAreaElement::saveFormControlState() const
123 {
124     return m_isDirty ? FormControlState(value()) : FormControlState();
125 }
126
127 void HTMLTextAreaElement::restoreFormControlState(const FormControlState& state)
128 {
129     setValue(state[0]);
130 }
131
132 void HTMLTextAreaElement::childrenChanged(const ChildChange& change)
133 {
134     HTMLElement::childrenChanged(change);
135     setLastChangeWasNotUserEdit();
136     if (m_isDirty)
137         setInnerTextValue(value());
138     else
139         setNonDirtyValue(defaultValue());
140 }
141
142 bool HTMLTextAreaElement::isPresentationAttribute(const QualifiedName& name) const
143 {
144     if (name == alignAttr) {
145         // Don't map 'align' attribute.  This matches what Firefox, Opera and IE do.
146         // See http://bugs.webkit.org/show_bug.cgi?id=7075
147         return false;
148     }
149
150     if (name == wrapAttr)
151         return true;
152     return HTMLTextFormControlElement::isPresentationAttribute(name);
153 }
154
155 void HTMLTextAreaElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
156 {
157     if (name == wrapAttr) {
158         if (shouldWrapText()) {
159             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePreWrap);
160             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
161         } else {
162             addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePre);
163             addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueNormal);
164         }
165     } else
166         HTMLTextFormControlElement::collectStyleForPresentationAttribute(name, value, style);
167 }
168
169 void HTMLTextAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
170 {
171     if (name == rowsAttr) {
172         int rows = value.toInt();
173         if (rows <= 0)
174             rows = defaultRows;
175         if (m_rows != rows) {
176             m_rows = rows;
177             if (renderer())
178                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
179         }
180     } else if (name == colsAttr) {
181         int cols = value.toInt();
182         if (cols <= 0)
183             cols = defaultCols;
184         if (m_cols != cols) {
185             m_cols = cols;
186             if (renderer())
187                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
188         }
189     } else if (name == wrapAttr) {
190         // The virtual/physical values were a Netscape extension of HTML 3.0, now deprecated.
191         // The soft/hard /off values are a recommendation for HTML 4 extension by IE and NS 4.
192         WrapMethod wrap;
193         if (equalIgnoringCase(value, "physical") || equalIgnoringCase(value, "hard") || equalIgnoringCase(value, "on"))
194             wrap = HardWrap;
195         else if (equalIgnoringCase(value, "off"))
196             wrap = NoWrap;
197         else
198             wrap = SoftWrap;
199         if (wrap != m_wrap) {
200             m_wrap = wrap;
201             if (renderer())
202                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
203         }
204     } else if (name == accesskeyAttr) {
205         // ignore for the moment
206     } else if (name == maxlengthAttr)
207         updateValidity();
208     else
209         HTMLTextFormControlElement::parseAttribute(name, value);
210 }
211
212 RenderPtr<RenderElement> HTMLTextAreaElement::createElementRenderer(Ref<RenderStyle>&& style, const RenderTreePosition&)
213 {
214     return createRenderer<RenderTextControlMultiLine>(*this, WTF::move(style));
215 }
216
217 bool HTMLTextAreaElement::appendFormData(FormDataList& encoding, bool)
218 {
219     if (name().isEmpty())
220         return false;
221
222     document().updateLayout();
223
224     const String& text = (m_wrap == HardWrap) ? valueWithHardLineBreaks() : value();
225     encoding.appendData(name(), text);
226
227     const AtomicString& dirnameAttrValue = fastGetAttribute(dirnameAttr);
228     if (!dirnameAttrValue.isNull())
229         encoding.appendData(dirnameAttrValue, directionForFormData());
230     return true;    
231 }
232
233 void HTMLTextAreaElement::reset()
234 {
235     setNonDirtyValue(defaultValue());
236 }
237
238 bool HTMLTextAreaElement::hasCustomFocusLogic() const
239 {
240     return true;
241 }
242
243 bool HTMLTextAreaElement::isKeyboardFocusable(KeyboardEvent*) const
244 {
245     // If a given text area can be focused at all, then it will always be keyboard focusable.
246     return isFocusable();
247 }
248
249 bool HTMLTextAreaElement::isMouseFocusable() const
250 {
251     return isFocusable();
252 }
253
254 void HTMLTextAreaElement::updateFocusAppearance(bool restorePreviousSelection)
255 {
256     if (!restorePreviousSelection || !hasCachedSelection()) {
257         // If this is the first focus, set a caret at the beginning of the text.  
258         // This matches some browsers' behavior; see bug 11746 Comment #15.
259         // http://bugs.webkit.org/show_bug.cgi?id=11746#c15
260         setSelectionRange(0, 0, SelectionHasNoDirection, Element::defaultFocusTextStateChangeIntent());
261     } else
262         restoreCachedSelection(Element::defaultFocusTextStateChangeIntent());
263
264     if (document().frame())
265         document().frame()->selection().revealSelection();
266 }
267
268 void HTMLTextAreaElement::defaultEventHandler(Event* event)
269 {
270     if (renderer() && (event->isMouseEvent() || event->isDragEvent() || event->eventInterface() == WheelEventInterfaceType || event->type() == eventNames().blurEvent))
271         forwardEvent(event);
272     else if (renderer() && is<BeforeTextInsertedEvent>(*event))
273         handleBeforeTextInsertedEvent(downcast<BeforeTextInsertedEvent>(event));
274
275     HTMLTextFormControlElement::defaultEventHandler(event);
276 }
277
278 void HTMLTextAreaElement::subtreeHasChanged()
279 {
280     setChangedSinceLastFormControlChangeEvent(true);
281     setFormControlValueMatchesRenderer(false);
282     updateValidity();
283
284     if (!focused())
285         return;
286
287     if (Frame* frame = document().frame())
288         frame->editor().textDidChangeInTextArea(this);
289     // When typing in a textarea, childrenChanged is not called, so we need to force the directionality check.
290     calculateAndAdjustDirectionality();
291 }
292
293 void HTMLTextAreaElement::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event) const
294 {
295     ASSERT(event);
296     ASSERT(renderer());
297     int signedMaxLength = maxLength();
298     if (signedMaxLength < 0)
299         return;
300     unsigned unsignedMaxLength = static_cast<unsigned>(signedMaxLength);
301
302     const String& currentValue = innerTextValue();
303     unsigned numberOfLineBreaksInCurrentValue = numberOfLineBreaks(currentValue);
304     if (upperBoundForLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue)
305         + upperBoundForLengthForSubmission(event->text(), numberOfLineBreaks(event->text())) < unsignedMaxLength)
306         return;
307
308     unsigned currentLength = computeLengthForSubmission(currentValue, numberOfLineBreaksInCurrentValue);
309     // selectionLength represents the selection length of this text field to be
310     // removed by this insertion.
311     // If the text field has no focus, we don't need to take account of the
312     // selection length. The selection is the source of text drag-and-drop in
313     // that case, and nothing in the text field will be removed.
314     unsigned selectionLength = focused() ? computeLengthForSubmission(plainText(document().frame()->selection().selection().toNormalizedRange().get())) : 0;
315     ASSERT(currentLength >= selectionLength);
316     unsigned baseLength = currentLength - selectionLength;
317     unsigned appendableLength = unsignedMaxLength > baseLength ? unsignedMaxLength - baseLength : 0;
318     event->setText(sanitizeUserInputValue(event->text(), appendableLength));
319 }
320
321 String HTMLTextAreaElement::sanitizeUserInputValue(const String& proposedValue, unsigned maxLength)
322 {
323     return proposedValue.left(numCharactersInGraphemeClusters(proposedValue, maxLength));
324 }
325
326 TextControlInnerTextElement* HTMLTextAreaElement::innerTextElement() const
327 {
328     return downcast<TextControlInnerTextElement>(userAgentShadowRoot()->firstChild());
329 }
330
331 void HTMLTextAreaElement::rendererWillBeDestroyed()
332 {
333     updateValue();
334 }
335
336 void HTMLTextAreaElement::updateValue() const
337 {
338     if (formControlValueMatchesRenderer())
339         return;
340
341     ASSERT(renderer());
342     m_value = innerTextValue();
343     const_cast<HTMLTextAreaElement*>(this)->setFormControlValueMatchesRenderer(true);
344     m_isDirty = true;
345     m_wasModifiedByUser = true;
346     const_cast<HTMLTextAreaElement*>(this)->updatePlaceholderVisibility();
347 }
348
349 String HTMLTextAreaElement::value() const
350 {
351     updateValue();
352     return m_value;
353 }
354
355 void HTMLTextAreaElement::setValue(const String& value)
356 {
357     setValueCommon(value);
358     m_isDirty = true;
359     updateValidity();
360 }
361
362 void HTMLTextAreaElement::setNonDirtyValue(const String& value)
363 {
364     setValueCommon(value);
365     m_isDirty = false;
366     updateValidity();
367 }
368
369 void HTMLTextAreaElement::setValueCommon(const String& newValue)
370 {
371     m_wasModifiedByUser = false;
372     // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
373     // We normalize line endings coming from JavaScript here.
374     String normalizedValue = newValue.isNull() ? "" : newValue;
375     normalizedValue.replace("\r\n", "\n");
376     normalizedValue.replace('\r', '\n');
377
378     // Return early because we don't want to move the caret or trigger other side effects
379     // when the value isn't changing. This matches Firefox behavior, at least.
380     if (normalizedValue == value())
381         return;
382
383     m_value = normalizedValue;
384     setInnerTextValue(m_value);
385     setLastChangeWasNotUserEdit();
386     updatePlaceholderVisibility();
387     setNeedsStyleRecalc();
388     setFormControlValueMatchesRenderer(true);
389
390     // Set the caret to the end of the text value.
391     if (document().focusedElement() == this) {
392         unsigned endOfString = m_value.length();
393         setSelectionRange(endOfString, endOfString);
394     }
395
396     setTextAsOfLastFormControlChangeEvent(normalizedValue);
397 }
398
399 String HTMLTextAreaElement::defaultValue() const
400 {
401     return TextNodeTraversal::contentsAsString(*this);
402 }
403
404 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
405 {
406     Ref<HTMLTextAreaElement> protectFromMutationEvents(*this);
407
408     // To preserve comments, remove only the text nodes, then add a single text node.
409     Vector<Ref<Text>> textNodes;
410     for (Text* textNode = TextNodeTraversal::firstChild(*this); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
411         textNodes.append(*textNode);
412
413     size_t size = textNodes.size();
414     for (size_t i = 0; i < size; ++i)
415         removeChild(textNodes[i].get(), IGNORE_EXCEPTION);
416
417     // Normalize line endings.
418     String value = defaultValue;
419     value.replace("\r\n", "\n");
420     value.replace('\r', '\n');
421
422     insertBefore(document().createTextNode(value), firstChild(), IGNORE_EXCEPTION);
423
424     if (!m_isDirty)
425         setNonDirtyValue(value);
426 }
427
428 int HTMLTextAreaElement::maxLength() const
429 {
430     bool ok;
431     int value = fastGetAttribute(maxlengthAttr).string().toInt(&ok);
432     return ok && value >= 0 ? value : -1;
433 }
434
435 void HTMLTextAreaElement::setMaxLength(int newValue, ExceptionCode& ec)
436 {
437     if (newValue < 0)
438         ec = INDEX_SIZE_ERR;
439     else
440         setIntegralAttribute(maxlengthAttr, newValue);
441 }
442
443 String HTMLTextAreaElement::validationMessage() const
444 {
445     if (!willValidate())
446         return String();
447
448     if (customError())
449         return customValidationMessage();
450
451     if (valueMissing())
452         return validationMessageValueMissingText();
453
454     if (tooLong())
455         return validationMessageTooLongText(computeLengthForSubmission(value()), maxLength());
456
457     return String();
458 }
459
460 bool HTMLTextAreaElement::valueMissing() const
461 {
462     return willValidate() && valueMissing(value());
463 }
464
465 bool HTMLTextAreaElement::tooLong() const
466 {
467     return willValidate() && tooLong(value(), CheckDirtyFlag);
468 }
469
470 bool HTMLTextAreaElement::tooLong(const String& value, NeedsToCheckDirtyFlag check) const
471 {
472     // Return false for the default value or value set by script even if it is
473     // longer than maxLength.
474     if (check == CheckDirtyFlag && !m_wasModifiedByUser)
475         return false;
476
477     int max = maxLength();
478     if (max < 0)
479         return false;
480     unsigned unsignedMax = static_cast<unsigned>(max);
481     unsigned numberOfLineBreaksInValue = numberOfLineBreaks(value);
482     return upperBoundForLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax
483         && computeLengthForSubmission(value, numberOfLineBreaksInValue) > unsignedMax;
484 }
485
486 bool HTMLTextAreaElement::isValidValue(const String& candidate) const
487 {
488     return !valueMissing(candidate) && !tooLong(candidate, IgnoreDirtyFlag);
489 }
490
491 void HTMLTextAreaElement::accessKeyAction(bool)
492 {
493     focus();
494 }
495
496 void HTMLTextAreaElement::setCols(int cols)
497 {
498     setIntegralAttribute(colsAttr, cols);
499 }
500
501 void HTMLTextAreaElement::setRows(int rows)
502 {
503     setIntegralAttribute(rowsAttr, rows);
504 }
505
506 bool HTMLTextAreaElement::shouldUseInputMethod()
507 {
508     return true;
509 }
510
511 HTMLElement* HTMLTextAreaElement::placeholderElement() const
512 {
513     return m_placeholder;
514 }
515
516 bool HTMLTextAreaElement::matchesReadWritePseudoClass() const
517 {
518     return !isDisabledOrReadOnly();
519 }
520
521 void HTMLTextAreaElement::updatePlaceholderText()
522 {
523     String placeholderText = strippedPlaceholder();
524     if (placeholderText.isEmpty()) {
525         if (m_placeholder) {
526             userAgentShadowRoot()->removeChild(*m_placeholder, ASSERT_NO_EXCEPTION);
527             m_placeholder = nullptr;
528         }
529         return;
530     }
531     if (!m_placeholder) {
532         RefPtr<HTMLDivElement> placeholder = HTMLDivElement::create(document());
533         m_placeholder = placeholder.get();
534         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
535         m_placeholder->setInlineStyleProperty(CSSPropertyDisplay, isPlaceholderVisible() ? CSSValueBlock : CSSValueNone, true);
536         userAgentShadowRoot()->insertBefore(*m_placeholder, innerTextElement()->nextSibling());
537     }
538     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
539 }
540
541 bool HTMLTextAreaElement::willRespondToMouseClickEvents()
542 {
543     return !isDisabledFormControl();
544 }
545
546 } // namespace WebCore