TextFieldInputType::handleBeforeTextInsertedEvent shouldn't use plainText
[WebKit-https.git] / Source / WebCore / html / TextFieldInputType.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  * Copyright (C) 2011 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "TextFieldInputType.h"
34
35 #include "BeforeTextInsertedEvent.h"
36 #include "Chrome.h"
37 #include "Editor.h"
38 #include "FormDataList.h"
39 #include "Frame.h"
40 #include "FrameSelection.h"
41 #include "HTMLInputElement.h"
42 #include "HTMLNames.h"
43 #include "KeyboardEvent.h"
44 #include "NodeRenderStyle.h"
45 #include "Page.h"
46 #include "RenderLayer.h"
47 #include "RenderTextControlSingleLine.h"
48 #include "RenderTheme.h"
49 #include "ShadowRoot.h"
50 #include "TextBreakIterator.h"
51 #include "TextControlInnerElements.h"
52 #include "TextEvent.h"
53 #include "TextIterator.h"
54 #include "WheelEvent.h"
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59
60 TextFieldInputType::TextFieldInputType(HTMLInputElement& element)
61     : InputType(element)
62 {
63 }
64
65 TextFieldInputType::~TextFieldInputType()
66 {
67     if (m_innerSpinButton)
68         m_innerSpinButton->removeSpinButtonOwner();
69 }
70
71 bool TextFieldInputType::isKeyboardFocusable(KeyboardEvent*) const
72 {
73 #if PLATFORM(IOS)
74     if (element().isReadOnly())
75         return false;
76 #endif
77     return element().isTextFormControlFocusable();
78 }
79
80 bool TextFieldInputType::isMouseFocusable() const
81 {
82     return element().isTextFormControlFocusable();
83 }
84
85 bool TextFieldInputType::isTextField() const
86 {
87     return true;
88 }
89
90 bool TextFieldInputType::valueMissing(const String& value) const
91 {
92     return element().isRequired() && value.isEmpty();
93 }
94
95 bool TextFieldInputType::canSetSuggestedValue()
96 {
97     return true;
98 }
99
100 void TextFieldInputType::setValue(const String& sanitizedValue, bool valueChanged, TextFieldEventBehavior eventBehavior)
101 {
102     // Grab this input element to keep reference even if JS event handler
103     // changes input type.
104     Ref<HTMLInputElement> input(element());
105
106     // We don't ask InputType::setValue to dispatch events because
107     // TextFieldInputType dispatches events different way from InputType.
108     InputType::setValue(sanitizedValue, valueChanged, DispatchNoEvent);
109
110     if (valueChanged)
111         updateInnerTextValue();
112
113     unsigned max = visibleValue().length();
114     if (input->focused())
115         input->setSelectionRange(max, max);
116     else
117         input->cacheSelectionInResponseToSetValue(max);
118
119     if (!valueChanged)
120         return;
121
122     switch (eventBehavior) {
123     case DispatchChangeEvent:
124         // If the user is still editing this field, dispatch an input event rather than a change event.
125         // The change event will be dispatched when editing finishes.
126         if (input->focused())
127             input->dispatchFormControlInputEvent();
128         else
129             input->dispatchFormControlChangeEvent();
130         break;
131
132     case DispatchInputAndChangeEvent: {
133         input->dispatchFormControlInputEvent();
134         input->dispatchFormControlChangeEvent();
135         break;
136     }
137
138     case DispatchNoEvent:
139         break;
140     }
141
142     // FIXME: Why do we do this when eventBehavior == DispatchNoEvent
143     if (!input->focused() || eventBehavior == DispatchNoEvent)
144         input->setTextAsOfLastFormControlChangeEvent(sanitizedValue);
145 }
146
147 void TextFieldInputType::handleKeydownEvent(KeyboardEvent* event)
148 {
149     if (!element().focused())
150         return;
151     Frame* frame = element().document().frame();
152     if (!frame || !frame->editor().doTextFieldCommandFromEvent(&element(), event))
153         return;
154     event->setDefaultHandled();
155 }
156
157 void TextFieldInputType::handleKeydownEventForSpinButton(KeyboardEvent* event)
158 {
159     if (element().isDisabledOrReadOnly())
160         return;
161     const String& key = event->keyIdentifier();
162     if (key == "Up")
163         spinButtonStepUp();
164     else if (key == "Down")
165         spinButtonStepDown();
166     else
167         return;
168     event->setDefaultHandled();
169 }
170
171 void TextFieldInputType::forwardEvent(Event* event)
172 {
173     if (m_innerSpinButton) {
174         m_innerSpinButton->forwardEvent(event);
175         if (event->defaultHandled())
176             return;
177     }
178
179     if (element().renderer() && (event->isMouseEvent() || event->isDragEvent() || event->eventInterface() == WheelEventInterfaceType || event->type() == eventNames().blurEvent || event->type() == eventNames().focusEvent)) {
180         RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(element().renderer());
181         if (event->type() == eventNames().blurEvent) {
182             if (RenderTextControlInnerBlock* innerTextRenderer = innerTextElement()->renderer()) {
183                 if (RenderLayer* innerLayer = innerTextRenderer->layer()) {
184                     IntSize scrollOffset(!renderTextControl->style().isLeftToRightDirection() ? innerLayer->scrollWidth() : 0, 0);
185                     innerLayer->scrollToOffset(scrollOffset, RenderLayer::ScrollOffsetClamped);
186                 }
187             }
188
189             renderTextControl->capsLockStateMayHaveChanged();
190         } else if (event->type() == eventNames().focusEvent)
191             renderTextControl->capsLockStateMayHaveChanged();
192
193         element().forwardEvent(event);
194     }
195 }
196
197 void TextFieldInputType::handleBlurEvent()
198 {
199     InputType::handleBlurEvent();
200     element().endEditing();
201 }
202
203 bool TextFieldInputType::shouldSubmitImplicitly(Event* event)
204 {
205     return (event->type() == eventNames().textInputEvent && event->eventInterface() == TextEventInterfaceType && toTextEvent(event)->data() == "\n") || InputType::shouldSubmitImplicitly(event);
206 }
207
208 RenderPtr<RenderElement> TextFieldInputType::createInputRenderer(PassRef<RenderStyle> style)
209 {
210     return createRenderer<RenderTextControlSingleLine>(element(), std::move(style));
211 }
212
213 bool TextFieldInputType::needsContainer() const
214 {
215 #if ENABLE(INPUT_SPEECH)
216     return element().isSpeechEnabled();
217 #else
218     return false;
219 #endif
220 }
221
222 bool TextFieldInputType::shouldHaveSpinButton() const
223 {
224     Document& document = element().document();
225     RefPtr<RenderTheme> theme = document.page() ? &document.page()->theme() : RenderTheme::defaultTheme();
226     return theme->shouldHaveSpinButton(&element());
227 }
228
229 void TextFieldInputType::createShadowSubtree()
230 {
231     ASSERT(element().shadowRoot());
232
233     ASSERT(!m_innerText);
234     ASSERT(!m_innerBlock);
235     ASSERT(!m_innerSpinButton);
236
237     Document& document = element().document();
238     bool shouldHaveSpinButton = this->shouldHaveSpinButton();
239     bool createsContainer = shouldHaveSpinButton || needsContainer();
240
241     m_innerText = TextControlInnerTextElement::create(document);
242     if (!createsContainer) {
243         element().userAgentShadowRoot()->appendChild(m_innerText, IGNORE_EXCEPTION);
244         return;
245     }
246
247     ShadowRoot* shadowRoot = element().userAgentShadowRoot();
248     m_container = TextControlInnerContainer::create(document);
249     m_container->setPseudo(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
250     shadowRoot->appendChild(m_container, IGNORE_EXCEPTION);
251
252     m_innerBlock = TextControlInnerElement::create(document);
253     m_innerBlock->appendChild(m_innerText, IGNORE_EXCEPTION);
254     m_container->appendChild(m_innerBlock, IGNORE_EXCEPTION);
255
256 #if ENABLE(INPUT_SPEECH)
257     ASSERT(!m_speechButton);
258     if (element().isSpeechEnabled()) {
259         m_speechButton = InputFieldSpeechButtonElement::create(document);
260         m_container->appendChild(m_speechButton, IGNORE_EXCEPTION);
261     }
262 #endif
263
264     if (shouldHaveSpinButton) {
265         m_innerSpinButton = SpinButtonElement::create(document, *this);
266         m_container->appendChild(m_innerSpinButton, IGNORE_EXCEPTION);
267     }
268 }
269
270 HTMLElement* TextFieldInputType::containerElement() const
271 {
272     return m_container.get();
273 }
274
275 HTMLElement* TextFieldInputType::innerBlockElement() const
276 {
277     return m_innerBlock.get();
278 }
279
280 TextControlInnerTextElement* TextFieldInputType::innerTextElement() const
281 {
282     ASSERT(m_innerText);
283     return m_innerText.get();
284 }
285
286 HTMLElement* TextFieldInputType::innerSpinButtonElement() const
287 {
288     return m_innerSpinButton.get();
289 }
290
291 #if ENABLE(INPUT_SPEECH)
292 HTMLElement* TextFieldInputType::speechButtonElement() const
293 {
294     return m_speechButton.get();
295 }
296 #endif
297
298 HTMLElement* TextFieldInputType::placeholderElement() const
299 {
300     return m_placeholder.get();
301 }
302
303 void TextFieldInputType::destroyShadowSubtree()
304 {
305     InputType::destroyShadowSubtree();
306     m_innerText.clear();
307     m_placeholder.clear();
308     m_innerBlock.clear();
309 #if ENABLE(INPUT_SPEECH)
310     m_speechButton.clear();
311 #endif
312     if (m_innerSpinButton)
313         m_innerSpinButton->removeSpinButtonOwner();
314     m_innerSpinButton.clear();
315     m_container.clear();
316 }
317
318 void TextFieldInputType::attributeChanged()
319 {
320     // FIXME: Updating the inner text on any attribute update should
321     // be unnecessary. We should figure out what attributes affect.
322     updateInnerTextValue();
323 }
324
325 void TextFieldInputType::disabledAttributeChanged()
326 {
327     if (m_innerSpinButton)
328         m_innerSpinButton->releaseCapture();
329 }
330
331 void TextFieldInputType::readonlyAttributeChanged()
332 {
333     if (m_innerSpinButton)
334         m_innerSpinButton->releaseCapture();
335 }
336
337 bool TextFieldInputType::supportsReadOnly() const
338 {
339     return true;
340 }
341
342 bool TextFieldInputType::shouldUseInputMethod() const
343 {
344     return true;
345 }
346
347 static bool isASCIILineBreak(UChar c)
348 {
349     return c == '\r' || c == '\n';
350 }
351
352 static String limitLength(const String& string, int maxLength)
353 {
354     unsigned newLength = numCharactersInGraphemeClusters(string, maxLength);
355     for (unsigned i = 0; i < newLength; ++i) {
356         const UChar current = string[i];
357         if (current < ' ' && current != '\t') {
358             newLength = i;
359             break;
360         }
361     }
362     return string.left(newLength);
363 }
364
365 String TextFieldInputType::sanitizeValue(const String& proposedValue) const
366 {
367     return limitLength(proposedValue.removeCharacters(isASCIILineBreak), HTMLInputElement::maximumLength);
368 }
369
370 void TextFieldInputType::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event)
371 {
372     // Make sure that the text to be inserted will not violate the maxLength.
373
374     // We use RenderTextControlSingleLine::text() instead of InputElement::value()
375     // because they can be mismatched by sanitizeValue() in
376     // HTMLInputElement::subtreeHasChanged() in some cases.
377     String innerText = element().innerTextValue();
378     unsigned oldLength = numGraphemeClusters(innerText);
379
380     // selectionLength represents the selection length of this text field to be
381     // removed by this insertion.
382     // If the text field has no focus, we don't need to take account of the
383     // selection length. The selection is the source of text drag-and-drop in
384     // that case, and nothing in the text field will be removed.
385     unsigned selectionLength = 0;
386     if (element().focused()) {
387         ASSERT(enclosingTextFormControl(element().document().frame()->selection().selection().start()) == &element());
388         selectionLength = numGraphemeClusters(innerText.substring(element().selectionStart(), element().selectionEnd()));
389     }
390     ASSERT(oldLength >= selectionLength);
391
392     // Selected characters will be removed by the next text event.
393     unsigned baseLength = oldLength - selectionLength;
394     unsigned maxLength = static_cast<unsigned>(isTextType() ? element().maxLength() : HTMLInputElement::maximumLength); // maxLength can never be negative.
395     unsigned appendableLength = maxLength > baseLength ? maxLength - baseLength : 0;
396
397     // Truncate the inserted text to avoid violating the maxLength and other constraints.
398     String eventText = event->text();
399     unsigned textLength = eventText.length();
400     while (textLength > 0 && isASCIILineBreak(eventText[textLength - 1]))
401         textLength--;
402     eventText.truncate(textLength);
403     eventText.replace("\r\n", " ");
404     eventText.replace('\r', ' ');
405     eventText.replace('\n', ' ');
406
407     event->setText(limitLength(eventText, appendableLength));
408 }
409
410 bool TextFieldInputType::shouldRespectListAttribute()
411 {
412     return InputType::themeSupportsDataListUI(this);
413 }
414
415 void TextFieldInputType::updatePlaceholderText()
416 {
417     if (!supportsPlaceholder())
418         return;
419     String placeholderText = element().strippedPlaceholder();
420     if (placeholderText.isEmpty()) {
421         if (m_placeholder) {
422             m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);
423             m_placeholder.clear();
424         }
425         return;
426     }
427     if (!m_placeholder) {
428         m_placeholder = HTMLDivElement::create(element().document());
429         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
430         element().userAgentShadowRoot()->insertBefore(m_placeholder, m_container ? m_container.get() : innerTextElement(), ASSERT_NO_EXCEPTION);
431     }
432     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
433 }
434
435 bool TextFieldInputType::appendFormData(FormDataList& list, bool multipart) const
436 {
437     InputType::appendFormData(list, multipart);
438     const AtomicString& dirnameAttrValue = element().fastGetAttribute(dirnameAttr);
439     if (!dirnameAttrValue.isNull())
440         list.appendData(dirnameAttrValue, element().directionForFormData());
441     return true;
442 }
443
444 String TextFieldInputType::convertFromVisibleValue(const String& visibleValue) const
445 {
446     return visibleValue;
447 }
448
449 void TextFieldInputType::subtreeHasChanged()
450 {
451     bool wasChanged = element().wasChangedSinceLastFormControlChangeEvent();
452     element().setChangedSinceLastFormControlChangeEvent(true);
453
454     // We don't need to call sanitizeUserInputValue() function here because
455     // HTMLInputElement::handleBeforeTextInsertedEvent() has already called
456     // sanitizeUserInputValue().
457     // sanitizeValue() is needed because IME input doesn't dispatch BeforeTextInsertedEvent.
458     element().setValueFromRenderer(sanitizeValue(convertFromVisibleValue(element().innerTextValue())));
459     element().updatePlaceholderVisibility(false);
460     // Recalc for :invalid change.
461     element().setNeedsStyleRecalc();
462
463     didSetValueByUserEdit(wasChanged ? ValueChangeStateChanged : ValueChangeStateNone);
464 }
465
466 void TextFieldInputType::didSetValueByUserEdit(ValueChangeState state)
467 {
468     if (!element().focused())
469         return;
470     if (Frame* frame = element().document().frame()) {
471         if (state == ValueChangeStateNone)
472             frame->editor().textFieldDidBeginEditing(&element());
473         frame->editor().textDidChangeInTextField(&element());
474     }
475 }
476
477 void TextFieldInputType::spinButtonStepDown()
478 {
479     stepUpFromRenderer(-1);
480 }
481
482 void TextFieldInputType::spinButtonStepUp()
483 {
484     stepUpFromRenderer(1);
485 }
486
487 void TextFieldInputType::updateInnerTextValue()
488 {
489     if (!element().suggestedValue().isNull()) {
490         element().setInnerTextValue(element().suggestedValue());
491         element().updatePlaceholderVisibility(false);
492     } else if (!element().formControlValueMatchesRenderer()) {
493         // Update the renderer value if the formControlValueMatchesRenderer() flag is false.
494         // It protects an unacceptable renderer value from being overwritten with the DOM value.
495         element().setInnerTextValue(visibleValue());
496         element().updatePlaceholderVisibility(false);
497     }
498 }
499
500 void TextFieldInputType::focusAndSelectSpinButtonOwner()
501 {
502     Ref<HTMLInputElement> input(element());
503     input->focus();
504     input->select();
505 }
506
507 bool TextFieldInputType::shouldSpinButtonRespondToMouseEvents()
508 {
509     return !element().isDisabledOrReadOnly();
510 }
511
512 bool TextFieldInputType::shouldSpinButtonRespondToWheelEvents()
513 {
514     return shouldSpinButtonRespondToMouseEvents() && element().focused();
515 }
516
517 } // namespace WebCore