Have the form control element directly handle validation message updating.

Source/core/html/HTMLFormControlElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 14 matching lines @@
 #include "config.h"
 #include "core/html/HTMLFormControlElement.h"
 
 #include "core/events/Event.h"
 #include "core/html/HTMLDataListElement.h"
 #include "core/html/HTMLFieldSetElement.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLegendElement.h"
 #include "core/html/ValidityState.h"
-#include "core/html/forms/ValidationMessage.h"
 #include "core/frame/UseCounter.h"
+#include "core/page/Page.h"
+#include "core/page/ValidationMessageClient.h"
 #include "core/rendering/RenderBox.h"
 #include "core/rendering/RenderTheme.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
     : LabelableElement(tagName, document)
     , m_disabled(false)
     , m_isAutofilled(false)
     , m_isReadOnly(false)
     , m_isRequired(false)
+    , m_hasValidationMessage(false)
     , m_ancestorDisabledState(AncestorDisabledStateUnknown)
     , m_dataListAncestorState(Unknown)
     , m_willValidateInitialized(false)
     , m_willValidate(true)
     , m_isValid(true)
     , m_wasChangedSinceLastFormControlChangeEvent(false)
     , m_wasFocusedByMouse(false)
 {
     setHasCustomStyleCallbacks();
     associateByParser(form);
@@ skipping 185 matching lines @@
     m_dataListAncestorState = Unknown;
     setNeedsWillValidateCheck();
     HTMLElement::insertedInto(insertionPoint);
     FormAssociatedElement::insertedInto(insertionPoint);
     return InsertionDone;
 }
 
 void HTMLFormControlElement::removedFrom(ContainerNode* insertionPoint)
 {
     hideVisibleValidationMessage();
-    m_validationMessage = nullptr;
+    m_hasValidationMessage = false;
     m_ancestorDisabledState = AncestorDisabledStateUnknown;
     m_dataListAncestorState = Unknown;
     HTMLElement::removedFrom(insertionPoint);
     FormAssociatedElement::removedFrom(insertionPoint);
 }
 
 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
 {
     m_wasChangedSinceLastFormControlChangeEvent = changed;
 }
@@ skipping 137 matching lines @@
 }
 
 void HTMLFormControlElement::updateVisibleValidationMessage()
 {
     Page* page = document().page();
     if (!page)
         return;
     String message;
     if (renderer() && willValidate())
         message = validationMessage().stripWhiteSpace();
-    if (!m_validationMessage)
-        m_validationMessage = ValidationMessage::create(this);
-    m_validationMessage->updateValidationMessage(message);
+
+    m_hasValidationMessage = true;
+    ValidationMessageClient* client = &page->validationMessageClient();
+    if (message.isEmpty())
+        client->hideValidationMessage(*this);
+    else
+        client->showValidationMessage(*this, message);
 }
 
 void HTMLFormControlElement::hideVisibleValidationMessage()
 {
-    if (m_validationMessage)
-        m_validationMessage->requestToHideMessage();
+    if (!m_hasValidationMessage)
+        return;
+
+    if (ValidationMessageClient* client = validationMessageClient())
+        client->hideValidationMessage(*this);
+}
+
+bool HTMLFormControlElement::isValidationMessageVisible() const
+{
+    if (!m_hasValidationMessage)
+        return false;
+
+    ValidationMessageClient* client = validationMessageClient();
+    if (!client)
+        return false;
+
+    return client->isValidationMessageVisible(*this);
+}
+
+ValidationMessageClient* HTMLFormControlElement::validationMessageClient() const
+{
+    Page* page = document().page();
+    if (!page)
+        return 0;
+
+    return &page->validationMessageClient();
 }
 
 bool HTMLFormControlElement::checkValidity(WillBeHeapVector<RefPtrWillBeMember<FormAssociatedElement> >* unhandledInvalidControls)
 {
     if (!willValidate() || isValidFormControlElement())
         return true;
     // An event handler can deref this object.
     RefPtrWillBeRawPtr<HTMLFormControlElement> protector(this);
     RefPtrWillBeRawPtr<Document> originalDocument(document());
     bool needsDefaultAction = dispatchEvent(Event::createCancelable(EventTypeNames::invalid));
@@ skipping 13 matching lines @@
 void HTMLFormControlElement::setNeedsValidityCheck()
 {
     bool newIsValid = valid();
     if (willValidate() && newIsValid != m_isValid) {
         // Update style for pseudo classes such as :valid :invalid.
         setNeedsStyleRecalc(SubtreeStyleChange);
     }
     m_isValid = newIsValid;
 
     // Updates only if this control already has a validation message.
-    if (m_validationMessage && m_validationMessage->isVisible()) {
+    if (isValidationMessageVisible()) {
         // Calls updateVisibleValidationMessage() even if m_isValid is not
-        // changed because a validation message can be chagned.
+        // changed because a validation message can be changed.
         updateVisibleValidationMessage();
     }
 }
 
 void HTMLFormControlElement::setCustomValidity(const String& error)
 {
     FormAssociatedElement::setCustomValidity(error);
     setNeedsValidityCheck();
 }
 
@@ skipping 33 matching lines @@
 
 void HTMLFormControlElement::setFocus(bool flag)
 {
     LabelableElement::setFocus(flag);
 
     if (!flag && wasChangedSinceLastFormControlChangeEvent())
         dispatchFormControlChangeEvent();
 }
 
 } // namespace Webcore