src/third_party/WebKit/Source/core/html/forms/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 "core/html/forms/TextFieldInputType.h"
  34
  35 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  36 #include "core/HTMLNames.h"
  37 #include "core/dom/NodeRenderStyle.h"
  38 #include "core/dom/shadow/ShadowRoot.h"
  39 #include "core/editing/FrameSelection.h"
  40 #include "core/editing/TextIterator.h"
  41 #include "core/events/BeforeTextInsertedEvent.h"
  42 #include "core/events/KeyboardEvent.h"
  43 #include "core/events/TextEvent.h"
  44 #include "core/frame/FrameHost.h"
  45 #include "core/frame/LocalFrame.h"
  46 #include "core/html/FormDataList.h"
  47 #include "core/html/HTMLInputElement.h"
  48 #include "core/html/shadow/ShadowElementNames.h"
  49 #include "core/html/shadow/TextControlInnerElements.h"
  50 #include "core/page/Chrome.h"
  51 #include "core/page/ChromeClient.h"
  52 #include "core/rendering/RenderDetailsMarker.h"
  53 #include "core/rendering/RenderLayer.h"
  54 #include "core/rendering/RenderTextControlSingleLine.h"
  55 #include "core/rendering/RenderTheme.h"
  56 #include "wtf/text/WTFString.h"
  57
  58 namespace blink {
  59
  60 using namespace HTMLNames;
  61
  62 class DataListIndicatorElement FINAL : public HTMLDivElement {
  63 private:
  64     inline DataListIndicatorElement(Document& document) : HTMLDivElement(document) { }
  65     inline HTMLInputElement* hostInput() const { return toHTMLInputElement(shadowHost()); }
  66
  67     virtual RenderObject* createRenderer(RenderStyle*) OVERRIDE
  68     {
  69         return new RenderDetailsMarker(this);
  70     }
  71
  72     virtual void* preDispatchEventHandler(Event* event) OVERRIDE
  73     {
  74         // Chromium opens autofill popup in a mousedown event listener
  75         // associated to the document. We don't want to open it in this case
  76         // because we opens a datalist chooser later.
  77         // FIXME: We should dispatch mousedown events even in such case.
  78         if (event->type() == EventTypeNames::mousedown)
  79             event->stopPropagation();
  80         return 0;
  81     }
  82
  83     virtual void defaultEventHandler(Event* event) OVERRIDE
  84     {
  85         ASSERT(document().isActive());
  86         if (event->type() != EventTypeNames::click)
  87             return;
  88         HTMLInputElement* host = hostInput();
  89         if (host && !host->isDisabledOrReadOnly()) {
  90             document().frameHost()->chrome().openTextDataListChooser(*host);
  91             event->setDefaultHandled();
  92         }
  93     }
  94
  95     virtual bool willRespondToMouseClickEvents() OVERRIDE
  96     {
  97         return hostInput() && !hostInput()->isDisabledOrReadOnly() && document().isActive();
  98     }
  99
 100 public:
 101     static PassRefPtrWillBeRawPtr<DataListIndicatorElement> create(Document& document)
 102     {
 103         RefPtrWillBeRawPtr<DataListIndicatorElement> element = adoptRefWillBeNoop(new DataListIndicatorElement(document));
 104         element->setShadowPseudoId(AtomicString("-webkit-calendar-picker-indicator", AtomicString::ConstructFromLiteral));
 105         element->setAttribute(idAttr, ShadowElementNames::pickerIndicator());
 106         return element.release();
 107     }
 108
 109 };
 110
 111 TextFieldInputType::TextFieldInputType(HTMLInputElement& element)
 112     : InputType(element)
 113 {
 114 }
 115
 116 TextFieldInputType::~TextFieldInputType()
 117 {
 118 #if !ENABLE(OILPAN)
 119     if (SpinButtonElement* spinButton = spinButtonElement())
 120         spinButton->removeSpinButtonOwner();
 121 #endif
 122 }
 123
 124 SpinButtonElement* TextFieldInputType::spinButtonElement() const
 125 {
 126     return toSpinButtonElement(element().userAgentShadowRoot()->getElementById(ShadowElementNames::spinButton()));
 127 }
 128
 129 bool TextFieldInputType::shouldShowFocusRingOnMouseFocus() const
 130 {
 131     return true;
 132 }
 133
 134 bool TextFieldInputType::isTextField() const
 135 {
 136     return true;
 137 }
 138
 139 bool TextFieldInputType::valueMissing(const String& value) const
 140 {
 141     return element().isRequired() && value.isEmpty();
 142 }
 143
 144 bool TextFieldInputType::canSetSuggestedValue()
 145 {
 146     return true;
 147 }
 148
 149 void TextFieldInputType::setValue(const String& sanitizedValue, bool valueChanged, TextFieldEventBehavior eventBehavior)
 150 {
 151     // Grab this input element to keep reference even if JS event handler
 152     // changes input type.
 153     RefPtrWillBeRawPtr<HTMLInputElement> input(element());
 154
 155     // We don't ask InputType::setValue to dispatch events because
 156     // TextFieldInputType dispatches events different way from InputType.
 157     InputType::setValue(sanitizedValue, valueChanged, DispatchNoEvent);
 158
 159     if (valueChanged)
 160         input->updateView();
 161
 162     unsigned max = visibleValue().length();
 163     if (input->focused())
 164         input->setSelectionRange(max, max);
 165     else
 166         input->cacheSelectionInResponseToSetValue(max);
 167
 168     if (!valueChanged)
 169         return;
 170
 171     switch (eventBehavior) {
 172     case DispatchChangeEvent:
 173         // If the user is still editing this field, dispatch an input event rather than a change event.
 174         // The change event will be dispatched when editing finishes.
 175         if (input->focused())
 176             input->dispatchFormControlInputEvent();
 177         else
 178             input->dispatchFormControlChangeEvent();
 179         break;
 180
 181     case DispatchInputAndChangeEvent: {
 182         input->dispatchFormControlInputEvent();
 183         input->dispatchFormControlChangeEvent();
 184         break;
 185     }
 186
 187     case DispatchNoEvent:
 188         break;
 189     }
 190
 191     if (!input->focused())
 192         input->setTextAsOfLastFormControlChangeEvent(sanitizedValue);
 193 }
 194
 195 void TextFieldInputType::handleKeydownEvent(KeyboardEvent* event)
 196 {
 197     if (!element().focused())
 198         return;
 199     if (Chrome* chrome = this->chrome()) {
 200         chrome->client().handleKeyboardEventOnTextField(element(), *event);
 201         return;
 202     }
 203     event->setDefaultHandled();
 204 }
 205
 206 void TextFieldInputType::handleKeydownEventForSpinButton(KeyboardEvent* event)
 207 {
 208     if (element().isDisabledOrReadOnly())
 209         return;
 210     const String& key = event->keyIdentifier();
 211     if (key == "Up")
 212         spinButtonStepUp();
 213     else if (key == "Down" && !event->altKey())
 214         spinButtonStepDown();
 215     else
 216         return;
 217     element().dispatchFormControlChangeEvent();
 218     event->setDefaultHandled();
 219 }
 220
 221 void TextFieldInputType::forwardEvent(Event* event)
 222 {
 223     if (SpinButtonElement* spinButton = spinButtonElement()) {
 224         spinButton->forwardEvent(event);
 225         if (event->defaultHandled())
 226             return;
 227     }
 228
 229     if (element().renderer() && (event->isMouseEvent() || event->isDragEvent() || event->hasInterface(EventNames::WheelEvent) || event->type() == EventTypeNames::blur || event->type() == EventTypeNames::focus)) {
 230         RenderTextControlSingleLine* renderTextControl = toRenderTextControlSingleLine(element().renderer());
 231         if (event->type() == EventTypeNames::blur) {
 232             if (RenderBox* innerEditorRenderer = element().innerEditorElement()->renderBox()) {
 233                 // FIXME: This class has no need to know about RenderLayer!
 234                 if (RenderLayer* innerLayer = innerEditorRenderer->layer()) {
 235                     if (RenderLayerScrollableArea* innerScrollableArea = innerLayer->scrollableArea()) {
 236                         IntSize scrollOffset(!renderTextControl->style()->isLeftToRightDirection() ? innerScrollableArea->scrollWidth().toInt() : 0, 0);
 237                         innerScrollableArea->scrollToOffset(scrollOffset, ScrollOffsetClamped);
 238                     }
 239                 }
 240             }
 241
 242             renderTextControl->capsLockStateMayHaveChanged();
 243         } else if (event->type() == EventTypeNames::focus) {
 244             renderTextControl->capsLockStateMayHaveChanged();
 245         }
 246
 247         element().forwardEvent(event);
 248     }
 249 }
 250
 251 void TextFieldInputType::handleFocusEvent(Element* oldFocusedNode, FocusType focusType)
 252 {
 253     InputType::handleFocusEvent(oldFocusedNode, focusType);
 254     element().beginEditing();
 255 }
 256
 257 void TextFieldInputType::handleBlurEvent()
 258 {
 259     InputType::handleBlurEvent();
 260     element().endEditing();
 261     if (SpinButtonElement *spinButton = spinButtonElement())
 262         spinButton->releaseCapture();
 263 }
 264
 265 bool TextFieldInputType::shouldSubmitImplicitly(Event* event)
 266 {
 267     return (event->type() == EventTypeNames::textInput && event->hasInterface(EventNames::TextEvent) && toTextEvent(event)->data() == "\n") || InputType::shouldSubmitImplicitly(event);
 268 }
 269
 270 RenderObject* TextFieldInputType::createRenderer(RenderStyle*) const
 271 {
 272     return new RenderTextControlSingleLine(&element());
 273 }
 274
 275 bool TextFieldInputType::shouldHaveSpinButton() const
 276 {
 277     return RenderTheme::theme().shouldHaveSpinButton(&element());
 278 }
 279
 280 void TextFieldInputType::createShadowSubtree()
 281 {
 282     ASSERT(element().shadow());
 283     ShadowRoot* shadowRoot = element().userAgentShadowRoot();
 284     ASSERT(!shadowRoot->hasChildren());
 285
 286     Document& document = element().document();
 287     bool shouldHaveSpinButton = this->shouldHaveSpinButton();
 288     bool shouldHaveDataListIndicator = element().hasValidDataListOptions();
 289     bool createsContainer = shouldHaveSpinButton || shouldHaveDataListIndicator || needsContainer();
 290
 291     RefPtrWillBeRawPtr<TextControlInnerEditorElement> innerEditor = TextControlInnerEditorElement::create(document);
 292     if (!createsContainer) {
 293         shadowRoot->appendChild(innerEditor.release());
 294         return;
 295     }
 296
 297     RefPtrWillBeRawPtr<TextControlInnerContainer> container = TextControlInnerContainer::create(document);
 298     container->setShadowPseudoId(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
 299     shadowRoot->appendChild(container);
 300
 301     RefPtrWillBeRawPtr<EditingViewPortElement> editingViewPort = EditingViewPortElement::create(document);
 302     editingViewPort->appendChild(innerEditor.release());
 303     container->appendChild(editingViewPort.release());
 304
 305     if (shouldHaveDataListIndicator)
 306         container->appendChild(DataListIndicatorElement::create(document));
 307     // FIXME: Because of a special handling for a spin button in
 308     // RenderTextControlSingleLine, we need to put it to the last position. It's
 309     // inconsistent with multiple-fields date/time types.
 310     if (shouldHaveSpinButton)
 311         container->appendChild(SpinButtonElement::create(document, *this));
 312
 313     // See listAttributeTargetChanged too.
 314 }
 315
 316 Element* TextFieldInputType::containerElement() const
 317 {
 318     return element().userAgentShadowRoot()->getElementById(ShadowElementNames::textFieldContainer());
 319 }
 320
 321 void TextFieldInputType::destroyShadowSubtree()
 322 {
 323     InputType::destroyShadowSubtree();
 324     if (SpinButtonElement* spinButton = spinButtonElement())
 325         spinButton->removeSpinButtonOwner();
 326 }
 327
 328 void TextFieldInputType::listAttributeTargetChanged()
 329 {
 330     Element* picker = element().userAgentShadowRoot()->getElementById(ShadowElementNames::pickerIndicator());
 331     bool didHavePickerIndicator = picker;
 332     bool willHavePickerIndicator = element().hasValidDataListOptions();
 333     if (didHavePickerIndicator == willHavePickerIndicator)
 334         return;
 335     if (willHavePickerIndicator) {
 336         Document& document = element().document();
 337         if (Element* container = containerElement()) {
 338             container->insertBefore(DataListIndicatorElement::create(document), spinButtonElement());
 339         } else {
 340             // FIXME: The following code is similar to createShadowSubtree(),
 341             // but they are different. We should simplify the code by making
 342             // containerElement mandatory.
 343             RefPtrWillBeRawPtr<Element> rpContainer = TextControlInnerContainer::create(document);
 344             rpContainer->setShadowPseudoId(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
 345             RefPtrWillBeRawPtr<Element> innerEditor = element().innerEditorElement();
 346             innerEditor->parentNode()->replaceChild(rpContainer.get(), innerEditor.get());
 347             RefPtrWillBeRawPtr<Element> editingViewPort = EditingViewPortElement::create(document);
 348             editingViewPort->appendChild(innerEditor.release());
 349             rpContainer->appendChild(editingViewPort.release());
 350             rpContainer->appendChild(DataListIndicatorElement::create(document));
 351             if (element().document().focusedElement() == element())
 352                 element().updateFocusAppearance(true /* restore selection */);
 353         }
 354     } else {
 355         picker->remove(ASSERT_NO_EXCEPTION);
 356     }
 357 }
 358
 359 void TextFieldInputType::attributeChanged()
 360 {
 361     // FIXME: Updating on any attribute update should be unnecessary. We should
 362     // figure out what attributes affect.
 363     updateView();
 364 }
 365
 366 void TextFieldInputType::disabledAttributeChanged()
 367 {
 368     if (SpinButtonElement* spinButton = spinButtonElement())
 369         spinButton->releaseCapture();
 370 }
 371
 372 void TextFieldInputType::readonlyAttributeChanged()
 373 {
 374     if (SpinButtonElement* spinButton = spinButtonElement())
 375         spinButton->releaseCapture();
 376 }
 377
 378 bool TextFieldInputType::supportsReadOnly() const
 379 {
 380     return true;
 381 }
 382
 383 static bool isASCIILineBreak(UChar c)
 384 {
 385     return c == '\r' || c == '\n';
 386 }
 387
 388 static String limitLength(const String& string, unsigned maxLength)
 389 {
 390     unsigned newLength = std::min(maxLength, string.length());
 391     if (newLength == string.length())
 392         return string;
 393     if (newLength > 0 && U16_IS_LEAD(string[newLength - 1]))
 394         --newLength;
 395     return string.left(newLength);
 396 }
 397
 398 String TextFieldInputType::sanitizeValue(const String& proposedValue) const
 399 {
 400     return limitLength(proposedValue.removeCharacters(isASCIILineBreak), HTMLInputElement::maximumLength);
 401 }
 402
 403 void TextFieldInputType::handleBeforeTextInsertedEvent(BeforeTextInsertedEvent* event)
 404 {
 405     // Make sure that the text to be inserted will not violate the maxLength.
 406
 407     // We use HTMLInputElement::innerEditorValue() instead of
 408     // HTMLInputElement::value() because they can be mismatched by
 409     // sanitizeValue() in HTMLInputElement::subtreeHasChanged() in some cases.
 410     unsigned oldLength = element().innerEditorValue().length();
 411
 412     // selectionLength represents the selection length of this text field to be
 413     // removed by this insertion.
 414     // If the text field has no focus, we don't need to take account of the
 415     // selection length. The selection is the source of text drag-and-drop in
 416     // that case, and nothing in the text field will be removed.
 417     unsigned selectionLength = element().focused() ? plainText(element().document().frame()->selection().selection().toNormalizedRange().get()).length() : 0;
 418     ASSERT(oldLength >= selectionLength);
 419
 420     // Selected characters will be removed by the next text event.
 421     unsigned baseLength = oldLength - selectionLength;
 422     unsigned maxLength = static_cast<unsigned>(this->maxLength()); // maxLength can never be negative.
 423     unsigned appendableLength = maxLength > baseLength ? maxLength - baseLength : 0;
 424
 425     // Truncate the inserted text to avoid violating the maxLength and other constraints.
 426     String eventText = event->text();
 427     unsigned textLength = eventText.length();
 428     while (textLength > 0 && isASCIILineBreak(eventText[textLength - 1]))
 429         textLength--;
 430     eventText.truncate(textLength);
 431     eventText.replace("\r\n", " ");
 432     eventText.replace('\r', ' ');
 433     eventText.replace('\n', ' ');
 434
 435     event->setText(limitLength(eventText, appendableLength));
 436 }
 437
 438 bool TextFieldInputType::shouldRespectListAttribute()
 439 {
 440     return true;
 441 }
 442
 443 void TextFieldInputType::updatePlaceholderText()
 444 {
 445     if (!supportsPlaceholder())
 446         return;
 447     HTMLElement* placeholder = element().placeholderElement();
 448     String placeholderText = element().strippedPlaceholder();
 449     if (placeholderText.isEmpty()) {
 450         if (placeholder)
 451             placeholder->remove(ASSERT_NO_EXCEPTION);
 452         return;
 453     }
 454     if (!placeholder) {
 455         RefPtrWillBeRawPtr<HTMLElement> newElement = HTMLDivElement::create(element().document());
 456         placeholder = newElement.get();
 457         placeholder->setShadowPseudoId(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
 458         placeholder->setAttribute(idAttr, ShadowElementNames::placeholder());
 459         Element* container = containerElement();
 460         Node* previous = container ? container : element().innerEditorElement();
 461         previous->parentNode()->insertBefore(placeholder, previous->nextSibling());
 462         ASSERT_WITH_SECURITY_IMPLICATION(placeholder->parentNode() == previous->parentNode());
 463     }
 464     placeholder->setTextContent(placeholderText);
 465 }
 466
 467 bool TextFieldInputType::appendFormData(FormDataList& list, bool multipart) const
 468 {
 469     InputType::appendFormData(list, multipart);
 470     const AtomicString& dirnameAttrValue = element().fastGetAttribute(dirnameAttr);
 471     if (!dirnameAttrValue.isNull())
 472         list.appendData(dirnameAttrValue, element().directionForFormData());
 473     return true;
 474 }
 475
 476 String TextFieldInputType::convertFromVisibleValue(const String& visibleValue) const
 477 {
 478     return visibleValue;
 479 }
 480
 481 void TextFieldInputType::subtreeHasChanged()
 482 {
 483     ASSERT(element().renderer());
 484
 485     bool wasChanged = element().wasChangedSinceLastFormControlChangeEvent();
 486     element().setChangedSinceLastFormControlChangeEvent(true);
 487
 488     // We don't need to call sanitizeUserInputValue() function here because
 489     // HTMLInputElement::handleBeforeTextInsertedEvent() has already called
 490     // sanitizeUserInputValue().
 491     // sanitizeValue() is needed because IME input doesn't dispatch BeforeTextInsertedEvent.
 492     element().setValueFromRenderer(sanitizeValue(convertFromVisibleValue(element().innerEditorValue())));
 493     element().updatePlaceholderVisibility(false);
 494     // Recalc for :invalid change.
 495     element().setNeedsStyleRecalc(SubtreeStyleChange);
 496
 497     didSetValueByUserEdit(wasChanged ? ValueChangeStateChanged : ValueChangeStateNone);
 498 }
 499
 500 void TextFieldInputType::didSetValueByUserEdit(ValueChangeState state)
 501 {
 502     if (!element().focused())
 503         return;
 504     if (Chrome* chrome = this->chrome())
 505         chrome->client().didChangeValueInTextField(element());
 506 }
 507
 508 void TextFieldInputType::spinButtonStepDown()
 509 {
 510     stepUpFromRenderer(-1);
 511 }
 512
 513 void TextFieldInputType::spinButtonStepUp()
 514 {
 515     stepUpFromRenderer(1);
 516 }
 517
 518 void TextFieldInputType::updateView()
 519 {
 520     if (!element().suggestedValue().isNull()) {
 521         element().setInnerEditorValue(element().suggestedValue());
 522         element().updatePlaceholderVisibility(false);
 523     } else if (element().needsToUpdateViewValue()) {
 524         // Update the view only if needsToUpdateViewValue is true. It protects
 525         // an unacceptable view value from being overwritten with the DOM value.
 526         //
 527         // e.g. <input type=number> has a view value "abc", and input.max is
 528         // updated. In this case, updateView() is called but we should not
 529         // update the view value.
 530         element().setInnerEditorValue(visibleValue());
 531         element().updatePlaceholderVisibility(false);
 532     }
 533 }
 534
 535 void TextFieldInputType::focusAndSelectSpinButtonOwner()
 536 {
 537     RefPtrWillBeRawPtr<HTMLInputElement> input(element());
 538     input->focus();
 539     input->select();
 540 }
 541
 542 bool TextFieldInputType::shouldSpinButtonRespondToMouseEvents()
 543 {
 544     return !element().isDisabledOrReadOnly();
 545 }
 546
 547 bool TextFieldInputType::shouldSpinButtonRespondToWheelEvents()
 548 {
 549     return shouldSpinButtonRespondToMouseEvents() && element().focused();
 550 }
 551
 552 void TextFieldInputType::spinButtonDidReleaseMouseCapture(SpinButtonElement::EventDispatch eventDispatch)
 553 {
 554     if (eventDispatch == SpinButtonElement::EventDispatchAllowed)
 555         element().dispatchFormControlChangeEvent();
 556 }
 557
 558 } // namespace blink