third_party/WebKit/Source/core/html/HTMLFormControlElement.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 Apple Inc. All rights reserved.
   6  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  *
  23  */
  24
  25 #include "config.h"
  26 #include "core/html/HTMLFormControlElement.h"
  27
  28 #include "core/dom/ElementTraversal.h"
  29 #include "core/events/Event.h"
  30 #include "core/frame/UseCounter.h"
  31 #include "core/html/HTMLDataListElement.h"
  32 #include "core/html/HTMLFieldSetElement.h"
  33 #include "core/html/HTMLFormElement.h"
  34 #include "core/html/HTMLInputElement.h"
  35 #include "core/html/HTMLLegendElement.h"
  36 #include "core/html/ValidityState.h"
  37 #include "core/inspector/ConsoleMessage.h"
  38 #include "core/layout/LayoutBox.h"
  39 #include "core/layout/LayoutTheme.h"
  40 #include "core/page/Page.h"
  41 #include "core/page/ValidationMessageClient.h"
  42 #include "platform/text/BidiTextRun.h"
  43 #include "wtf/Vector.h"
  44
  45 namespace blink {
  46
  47 using namespace HTMLNames;
  48
  49 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
  50     : LabelableElement(tagName, document)
  51     , m_disabled(false)
  52     , m_isAutofilled(false)
  53     , m_isReadOnly(false)
  54     , m_isRequired(false)
  55     , m_hasValidationMessage(false)
  56     , m_ancestorDisabledState(AncestorDisabledStateUnknown)
  57     , m_dataListAncestorState(Unknown)
  58     , m_willValidateInitialized(false)
  59     , m_willValidate(true)
  60     , m_isValid(true)
  61     , m_validityIsDirty(false)
  62     , m_wasChangedSinceLastFormControlChangeEvent(false)
  63     , m_wasFocusedByMouse(false)
  64 {
  65     setHasCustomStyleCallbacks();
  66     associateByParser(form);
  67 }
  68
  69 HTMLFormControlElement::~HTMLFormControlElement()
  70 {
  71 #if !ENABLE(OILPAN)
  72 #if ENABLE(ASSERT)
  73     // Recalculate m_willValidate and m_isValid for the vtbl change in order to
  74     // avoid assertion failures in isValidElement() called in setForm(0).
  75     setNeedsWillValidateCheck();
  76     setNeedsValidityCheck();
  77 #endif
  78     setForm(0);
  79 #endif
  80 }
  81
  82 DEFINE_TRACE(HTMLFormControlElement)
  83 {
  84     FormAssociatedElement::trace(visitor);
  85     LabelableElement::trace(visitor);
  86 }
  87
  88 String HTMLFormControlElement::formEnctype() const
  89 {
  90     const AtomicString& formEnctypeAttr = fastGetAttribute(formenctypeAttr);
  91     if (formEnctypeAttr.isNull())
  92         return emptyString();
  93     return FormSubmission::Attributes::parseEncodingType(formEnctypeAttr);
  94 }
  95
  96 void HTMLFormControlElement::setFormEnctype(const AtomicString& value)
  97 {
  98     setAttribute(formenctypeAttr, value);
  99 }
 100
 101 String HTMLFormControlElement::formMethod() const
 102 {
 103     const AtomicString& formMethodAttr = fastGetAttribute(formmethodAttr);
 104     if (formMethodAttr.isNull())
 105         return emptyString();
 106     return FormSubmission::Attributes::methodString(FormSubmission::Attributes::parseMethodType(formMethodAttr));
 107 }
 108
 109 void HTMLFormControlElement::setFormMethod(const AtomicString& value)
 110 {
 111     setAttribute(formmethodAttr, value);
 112 }
 113
 114 bool HTMLFormControlElement::formNoValidate() const
 115 {
 116     return fastHasAttribute(formnovalidateAttr);
 117 }
 118
 119 void HTMLFormControlElement::updateAncestorDisabledState() const
 120 {
 121     HTMLFieldSetElement* fieldSetAncestor = 0;
 122     ContainerNode* legendAncestor = 0;
 123     for (HTMLElement* ancestor = Traversal<HTMLElement>::firstAncestor(*this); ancestor; ancestor = Traversal<HTMLElement>::firstAncestor(*ancestor)) {
 124         if (!legendAncestor && isHTMLLegendElement(*ancestor))
 125             legendAncestor = ancestor;
 126         if (isHTMLFieldSetElement(*ancestor)) {
 127             fieldSetAncestor = toHTMLFieldSetElement(ancestor);
 128             break;
 129         }
 130     }
 131     m_ancestorDisabledState = (fieldSetAncestor && fieldSetAncestor->isDisabledFormControl() && !(legendAncestor && legendAncestor == fieldSetAncestor->legend())) ? AncestorDisabledStateDisabled : AncestorDisabledStateEnabled;
 132 }
 133
 134 void HTMLFormControlElement::ancestorDisabledStateWasChanged()
 135 {
 136     m_ancestorDisabledState = AncestorDisabledStateUnknown;
 137     disabledAttributeChanged();
 138 }
 139
 140 void HTMLFormControlElement::reset()
 141 {
 142     setAutofilled(false);
 143     resetImpl();
 144 }
 145
 146 void HTMLFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 147 {
 148     if (name == formAttr) {
 149         formAttributeChanged();
 150         UseCounter::count(document(), UseCounter::FormAttribute);
 151     } else if (name == disabledAttr) {
 152         bool oldDisabled = m_disabled;
 153         m_disabled = !value.isNull();
 154         if (oldDisabled != m_disabled)
 155             disabledAttributeChanged();
 156     } else if (name == readonlyAttr) {
 157         bool wasReadOnly = m_isReadOnly;
 158         m_isReadOnly = !value.isNull();
 159         if (wasReadOnly != m_isReadOnly) {
 160             setNeedsWillValidateCheck();
 161             setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::fromAttribute(name));
 162             if (layoutObject())
 163                 LayoutTheme::theme().controlStateChanged(*layoutObject(), ReadOnlyControlState);
 164         }
 165     } else if (name == requiredAttr) {
 166         bool wasRequired = m_isRequired;
 167         m_isRequired = !value.isNull();
 168         if (wasRequired != m_isRequired)
 169             requiredAttributeChanged();
 170         UseCounter::count(document(), UseCounter::RequiredAttribute);
 171     } else if (name == autofocusAttr) {
 172         HTMLElement::parseAttribute(name, value);
 173         UseCounter::count(document(), UseCounter::AutoFocusAttribute);
 174     } else {
 175         HTMLElement::parseAttribute(name, value);
 176     }
 177 }
 178
 179 void HTMLFormControlElement::disabledAttributeChanged()
 180 {
 181     setNeedsWillValidateCheck();
 182     pseudoStateChanged(CSSSelector::PseudoDisabled);
 183     pseudoStateChanged(CSSSelector::PseudoEnabled);
 184     if (layoutObject())
 185         LayoutTheme::theme().controlStateChanged(*layoutObject(), EnabledControlState);
 186     if (isDisabledFormControl() && treeScope().adjustedFocusedElement() == this) {
 187         // We might want to call blur(), but it's dangerous to dispatch events
 188         // here.
 189         document().setNeedsFocusedElementCheck();
 190     }
 191 }
 192
 193 void HTMLFormControlElement::requiredAttributeChanged()
 194 {
 195     setNeedsValidityCheck();
 196     pseudoStateChanged(CSSSelector::PseudoRequired);
 197     pseudoStateChanged(CSSSelector::PseudoOptional);
 198 }
 199
 200 bool HTMLFormControlElement::supportsAutofocus() const
 201 {
 202     return false;
 203 }
 204
 205 bool HTMLFormControlElement::isAutofocusable() const
 206 {
 207     return fastHasAttribute(autofocusAttr) && supportsAutofocus();
 208 }
 209
 210 void HTMLFormControlElement::setAutofilled(bool autofilled)
 211 {
 212     if (autofilled == m_isAutofilled)
 213         return;
 214
 215     m_isAutofilled = autofilled;
 216     pseudoStateChanged(CSSSelector::PseudoAutofill);
 217 }
 218
 219 static bool shouldAutofocusOnAttach(const HTMLFormControlElement* element)
 220 {
 221     if (!element->isAutofocusable())
 222         return false;
 223     if (element->document().isSandboxed(SandboxAutomaticFeatures)) {
 224         // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists.
 225         element->document().addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Blocked autofocusing on a form control because the form's frame is sandboxed and the 'allow-scripts' permission is not set."));
 226         return false;
 227     }
 228
 229     return true;
 230 }
 231
 232 void HTMLFormControlElement::attach(const AttachContext& context)
 233 {
 234     HTMLElement::attach(context);
 235
 236     if (!layoutObject())
 237         return;
 238
 239     // The call to updateFromElement() needs to go after the call through
 240     // to the base class's attach() because that can sometimes do a close
 241     // on the layoutObject.
 242     layoutObject()->updateFromElement();
 243
 244     // FIXME: Autofocus handling should be moved to insertedInto according to
 245     // the standard.
 246     if (shouldAutofocusOnAttach(this))
 247         document().setAutofocusElement(this);
 248 }
 249
 250 void HTMLFormControlElement::didMoveToNewDocument(Document& oldDocument)
 251 {
 252     FormAssociatedElement::didMoveToNewDocument(oldDocument);
 253     HTMLElement::didMoveToNewDocument(oldDocument);
 254 }
 255
 256 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode* insertionPoint)
 257 {
 258     m_ancestorDisabledState = AncestorDisabledStateUnknown;
 259     m_dataListAncestorState = Unknown;
 260     setNeedsWillValidateCheck();
 261     HTMLElement::insertedInto(insertionPoint);
 262     FormAssociatedElement::insertedInto(insertionPoint);
 263     fieldSetAncestorsSetNeedsValidityCheck(insertionPoint);
 264
 265     // Trigger for elements outside of forms.
 266     if (!formOwner() && insertionPoint->inDocument())
 267         document().didAssociateFormControl(this);
 268
 269     return InsertionDone;
 270 }
 271
 272 void HTMLFormControlElement::removedFrom(ContainerNode* insertionPoint)
 273 {
 274     fieldSetAncestorsSetNeedsValidityCheck(insertionPoint);
 275     hideVisibleValidationMessage();
 276     m_hasValidationMessage = false;
 277     m_ancestorDisabledState = AncestorDisabledStateUnknown;
 278     m_dataListAncestorState = Unknown;
 279     setNeedsWillValidateCheck();
 280     HTMLElement::removedFrom(insertionPoint);
 281     FormAssociatedElement::removedFrom(insertionPoint);
 282     document().removeFormAssociation(this);
 283 }
 284
 285 void HTMLFormControlElement::willChangeForm()
 286 {
 287     FormAssociatedElement::willChangeForm();
 288     formOwnerSetNeedsValidityCheck();
 289 }
 290
 291 void HTMLFormControlElement::didChangeForm()
 292 {
 293     FormAssociatedElement::didChangeForm();
 294     formOwnerSetNeedsValidityCheck();
 295 }
 296
 297 void HTMLFormControlElement::formOwnerSetNeedsValidityCheck()
 298 {
 299     if (HTMLFormElement* form = formOwner()) {
 300         form->pseudoStateChanged(CSSSelector::PseudoValid);
 301         form->pseudoStateChanged(CSSSelector::PseudoInvalid);
 302     }
 303 }
 304
 305 void HTMLFormControlElement::fieldSetAncestorsSetNeedsValidityCheck(Node* node)
 306 {
 307     if (!node)
 308         return;
 309     for (HTMLFieldSetElement* fieldSet = Traversal<HTMLFieldSetElement>::firstAncestorOrSelf(*node); fieldSet; fieldSet = Traversal<HTMLFieldSetElement>::firstAncestor(*fieldSet)) {
 310         fieldSet->pseudoStateChanged(CSSSelector::PseudoValid);
 311         fieldSet->pseudoStateChanged(CSSSelector::PseudoInvalid);
 312     }
 313 }
 314
 315 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
 316 {
 317     m_wasChangedSinceLastFormControlChangeEvent = changed;
 318 }
 319
 320 void HTMLFormControlElement::dispatchChangeEvent()
 321 {
 322     dispatchScopedEvent(Event::createBubble(EventTypeNames::change));
 323 }
 324
 325 void HTMLFormControlElement::dispatchFormControlChangeEvent()
 326 {
 327     dispatchChangeEvent();
 328     setChangedSinceLastFormControlChangeEvent(false);
 329 }
 330
 331 void HTMLFormControlElement::dispatchFormControlInputEvent()
 332 {
 333     setChangedSinceLastFormControlChangeEvent(true);
 334     HTMLElement::dispatchInputEvent();
 335 }
 336
 337 HTMLFormElement* HTMLFormControlElement::formOwner() const
 338 {
 339     return FormAssociatedElement::form();
 340 }
 341
 342 bool HTMLFormControlElement::isDisabledFormControl() const
 343 {
 344     if (m_disabled)
 345         return true;
 346
 347     if (m_ancestorDisabledState == AncestorDisabledStateUnknown)
 348         updateAncestorDisabledState();
 349     return m_ancestorDisabledState == AncestorDisabledStateDisabled;
 350 }
 351
 352 bool HTMLFormControlElement::isRequired() const
 353 {
 354     return m_isRequired;
 355 }
 356
 357 String HTMLFormControlElement::resultForDialogSubmit()
 358 {
 359     return fastGetAttribute(valueAttr);
 360 }
 361
 362 void HTMLFormControlElement::didRecalcStyle(StyleRecalcChange)
 363 {
 364     if (LayoutObject* layoutObject = this->layoutObject())
 365         layoutObject->updateFromElement();
 366 }
 367
 368 bool HTMLFormControlElement::supportsFocus() const
 369 {
 370     return !isDisabledFormControl();
 371 }
 372
 373 bool HTMLFormControlElement::isKeyboardFocusable() const
 374 {
 375     // Skip tabIndex check in a parent class.
 376     return isFocusable();
 377 }
 378
 379 bool HTMLFormControlElement::shouldShowFocusRingOnMouseFocus() const
 380 {
 381     return false;
 382 }
 383
 384 bool HTMLFormControlElement::shouldHaveFocusAppearance() const
 385 {
 386     return !m_wasFocusedByMouse || shouldShowFocusRingOnMouseFocus();
 387 }
 388
 389 void HTMLFormControlElement::dispatchFocusEvent(Element* oldFocusedElement, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
 390 {
 391     if (type != WebFocusTypePage)
 392         m_wasFocusedByMouse = type == WebFocusTypeMouse;
 393     // ContainerNode::handleStyleChangeOnFocusStateChange() will inform LayoutTheme about the focus state change.
 394     HTMLElement::dispatchFocusEvent(oldFocusedElement, type, sourceCapabilities);
 395 }
 396
 397 void HTMLFormControlElement::willCallDefaultEventHandler(const Event& event)
 398 {
 399     if (!m_wasFocusedByMouse)
 400         return;
 401     if (!event.isKeyboardEvent() || event.type() != EventTypeNames::keydown)
 402         return;
 403
 404     bool oldShouldHaveFocusAppearance = shouldHaveFocusAppearance();
 405     m_wasFocusedByMouse = false;
 406
 407     // Change of m_wasFocusByMouse may affect shouldHaveFocusAppearance() and LayoutTheme::isFocused().
 408     // Inform LayoutTheme if shouldHaveFocusAppearance() changes.
 409     if (oldShouldHaveFocusAppearance != shouldHaveFocusAppearance() && layoutObject())
 410         LayoutTheme::theme().controlStateChanged(*layoutObject(), FocusControlState);
 411 }
 412
 413 short HTMLFormControlElement::tabIndex() const
 414 {
 415     // Skip the supportsFocus check in HTMLElement.
 416     return Element::tabIndex();
 417 }
 418
 419 bool HTMLFormControlElement::recalcWillValidate() const
 420 {
 421     if (m_dataListAncestorState == Unknown) {
 422         if (Traversal<HTMLDataListElement>::firstAncestor(*this))
 423             m_dataListAncestorState = InsideDataList;
 424         else
 425             m_dataListAncestorState = NotInsideDataList;
 426     }
 427     return m_dataListAncestorState == NotInsideDataList && !isDisabledOrReadOnly();
 428 }
 429
 430 bool HTMLFormControlElement::willValidate() const
 431 {
 432     if (!m_willValidateInitialized || m_dataListAncestorState == Unknown) {
 433         const_cast<HTMLFormControlElement*>(this)->setNeedsWillValidateCheck();
 434     } else {
 435         // If the following assertion fails, setNeedsWillValidateCheck() is not
 436         // called correctly when something which changes recalcWillValidate() result
 437         // is updated.
 438         ASSERT(m_willValidate == recalcWillValidate());
 439     }
 440     return m_willValidate;
 441 }
 442
 443 void HTMLFormControlElement::setNeedsWillValidateCheck()
 444 {
 445     // We need to recalculate willValidate immediately because willValidate change can causes style change.
 446     bool newWillValidate = recalcWillValidate();
 447     if (m_willValidateInitialized && m_willValidate == newWillValidate)
 448         return;
 449     m_willValidateInitialized = true;
 450     m_willValidate = newWillValidate;
 451     setNeedsValidityCheck();
 452     // No need to trigger style recalculation here because
 453     // setNeedsValidityCheck() does it in the right away. This relies on
 454     // the assumption that valid() is always true if willValidate() is false.
 455
 456     if (!m_willValidate)
 457         hideVisibleValidationMessage();
 458 }
 459
 460 void HTMLFormControlElement::findCustomValidationMessageTextDirection(const String& message, TextDirection &messageDir, String& subMessage, TextDirection &subMessageDir)
 461 {
 462     subMessage = fastGetAttribute(titleAttr);
 463     messageDir = determineDirectionality(message);
 464     if (!subMessage.isEmpty())
 465         subMessageDir = layoutObject()->style()->direction();
 466 }
 467
 468 void HTMLFormControlElement::updateVisibleValidationMessage()
 469 {
 470     Page* page = document().page();
 471     if (!page)
 472         return;
 473     String message;
 474     if (layoutObject() && willValidate())
 475         message = validationMessage().stripWhiteSpace();
 476
 477     m_hasValidationMessage = true;
 478     ValidationMessageClient* client = &page->validationMessageClient();
 479     TextDirection messageDir = LTR;
 480     TextDirection subMessageDir = LTR;
 481     String subMessage = String();
 482     if (message.isEmpty())
 483         client->hideValidationMessage(*this);
 484     else
 485         findCustomValidationMessageTextDirection(message, messageDir, subMessage, subMessageDir);
 486     client->showValidationMessage(*this, message, messageDir, subMessage, subMessageDir);
 487 }
 488
 489 void HTMLFormControlElement::hideVisibleValidationMessage()
 490 {
 491     if (!m_hasValidationMessage)
 492         return;
 493
 494     if (ValidationMessageClient* client = validationMessageClient())
 495         client->hideValidationMessage(*this);
 496 }
 497
 498 bool HTMLFormControlElement::isValidationMessageVisible() const
 499 {
 500     if (!m_hasValidationMessage)
 501         return false;
 502
 503     ValidationMessageClient* client = validationMessageClient();
 504     if (!client)
 505         return false;
 506
 507     return client->isValidationMessageVisible(*this);
 508 }
 509
 510 ValidationMessageClient* HTMLFormControlElement::validationMessageClient() const
 511 {
 512     Page* page = document().page();
 513     if (!page)
 514         return nullptr;
 515
 516     return &page->validationMessageClient();
 517 }
 518
 519 bool HTMLFormControlElement::checkValidity(WillBeHeapVector<RefPtrWillBeMember<HTMLFormControlElement>>* unhandledInvalidControls, CheckValidityEventBehavior eventBehavior)
 520 {
 521     if (isValidElement())
 522         return true;
 523     if (eventBehavior != CheckValidityDispatchInvalidEvent)
 524         return false;
 525     // An event handler can deref this object.
 526     RefPtrWillBeRawPtr<HTMLFormControlElement> protector(this);
 527     RefPtrWillBeRawPtr<Document> originalDocument(document());
 528     bool needsDefaultAction = dispatchEvent(Event::createCancelable(EventTypeNames::invalid));
 529     if (needsDefaultAction && unhandledInvalidControls && inDocument() && originalDocument == document())
 530         unhandledInvalidControls->append(this);
 531     return false;
 532 }
 533
 534 void HTMLFormControlElement::showValidationMessage()
 535 {
 536     scrollIntoViewIfNeeded(false);
 537     RefPtrWillBeRawPtr<HTMLFormControlElement> protector(this);
 538     focus();
 539     updateVisibleValidationMessage();
 540 }
 541
 542 bool HTMLFormControlElement::reportValidity()
 543 {
 544     WillBeHeapVector<RefPtrWillBeMember<HTMLFormControlElement>> unhandledInvalidControls;
 545     bool isValid = checkValidity(&unhandledInvalidControls, CheckValidityDispatchInvalidEvent);
 546     if (isValid || unhandledInvalidControls.isEmpty())
 547         return isValid;
 548     ASSERT(unhandledInvalidControls.size() == 1);
 549     ASSERT(unhandledInvalidControls[0].get() == this);
 550     // Update layout now before calling isFocusable(), which has
 551     // !layoutObject()->needsLayout() assertion.
 552     document().updateLayoutIgnorePendingStylesheets();
 553     if (isFocusable()) {
 554         showValidationMessage();
 555         return false;
 556     }
 557     if (document().frame()) {
 558         String message("An invalid form control with name='%name' is not focusable.");
 559         message.replace("%name", name());
 560         document().addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, message));
 561     }
 562     return false;
 563 }
 564
 565 bool HTMLFormControlElement::matchesValidityPseudoClasses() const
 566 {
 567     return willValidate();
 568 }
 569
 570 bool HTMLFormControlElement::isValidElement()
 571 {
 572     if (m_validityIsDirty) {
 573         m_isValid = !willValidate() || valid();
 574         m_validityIsDirty = false;
 575     } else {
 576         // If the following assertion fails, setNeedsValidityCheck() is not
 577         // called correctly when something which changes validity is updated.
 578         ASSERT(m_isValid == (!willValidate() || valid()));
 579     }
 580     return m_isValid;
 581 }
 582
 583 void HTMLFormControlElement::setNeedsValidityCheck()
 584 {
 585     if (!m_validityIsDirty) {
 586         m_validityIsDirty = true;
 587         formOwnerSetNeedsValidityCheck();
 588         fieldSetAncestorsSetNeedsValidityCheck(parentNode());
 589         pseudoStateChanged(CSSSelector::PseudoValid);
 590         pseudoStateChanged(CSSSelector::PseudoInvalid);
 591     }
 592
 593     // Updates only if this control already has a validation message.
 594     if (isValidationMessageVisible()) {
 595         // Calls updateVisibleValidationMessage() even if m_isValid is not
 596         // changed because a validation message can be changed.
 597         updateVisibleValidationMessage();
 598     }
 599 }
 600
 601 void HTMLFormControlElement::setCustomValidity(const String& error)
 602 {
 603     FormAssociatedElement::setCustomValidity(error);
 604     setNeedsValidityCheck();
 605 }
 606
 607 void HTMLFormControlElement::dispatchBlurEvent(Element* newFocusedElement, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
 608 {
 609     if (type != WebFocusTypePage)
 610         m_wasFocusedByMouse = false;
 611     HTMLElement::dispatchBlurEvent(newFocusedElement, type, sourceCapabilities);
 612     hideVisibleValidationMessage();
 613 }
 614
 615 bool HTMLFormControlElement::isSuccessfulSubmitButton() const
 616 {
 617     return canBeSuccessfulSubmitButton() && !isDisabledFormControl();
 618 }
 619
 620 bool HTMLFormControlElement::isDefaultButtonForForm() const
 621 {
 622     return isSuccessfulSubmitButton() && form() && form()->defaultButton() == this;
 623 }
 624
 625 HTMLFormControlElement* HTMLFormControlElement::enclosingFormControlElement(Node* node)
 626 {
 627     if (!node)
 628         return nullptr;
 629     return Traversal<HTMLFormControlElement>::firstAncestorOrSelf(*node);
 630 }
 631
 632 String HTMLFormControlElement::nameForAutofill() const
 633 {
 634     String fullName = name();
 635     String trimmedName = fullName.stripWhiteSpace();
 636     if (!trimmedName.isEmpty())
 637         return trimmedName;
 638     fullName = getIdAttribute();
 639     trimmedName = fullName.stripWhiteSpace();
 640     return trimmedName;
 641 }
 642
 643 void HTMLFormControlElement::setFocus(bool flag)
 644 {
 645     LabelableElement::setFocus(flag);
 646
 647     if (!flag && wasChangedSinceLastFormControlChangeEvent())
 648         dispatchFormControlChangeEvent();
 649 }
 650
 651 void HTMLFormControlElement::copyNonAttributePropertiesFromElement(const Element& source)
 652 {
 653     HTMLElement::copyNonAttributePropertiesFromElement(source);
 654     setNeedsValidityCheck();
 655 }
 656
 657 } // namespace blink