Implement :valid and :invalid pseudoclass for <form>

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 228 matching lines @@
     if (shouldAutofocusOnAttach(this))
         document().setAutofocusElement(this);
 }
 
 void HTMLFormControlElement::didMoveToNewDocument(Document& oldDocument)
 {
     FormAssociatedElement::didMoveToNewDocument(oldDocument);
     HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
+void HTMLFormControlElement::setFormOwnerNeedsStyleRecalc()

[keishi, 2014/10/03 03:44:13]

I think this should be done by the HTMLFormElement in a method like
HTMLFormElement::setNeedsValidityCheck(). We have some exceptions but I think
elements should decide if it needs style recalc for itself not for other
elements. For example in this case, if you implement caching HTMLFormElement
could tell when the validity hasn't changed and avoid a style recalc.

[Bartek Nowierski, 2014/10/03 06:01:33]

Done.

+{
+    HTMLFormElement* form = formOwner();
+    if (form)
+        form->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::createWithExtraData(StyleChangeReason::PseudoClass, StyleChangeExtraData::Invalid));
+}
+
 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode* insertionPoint)
 {
     m_ancestorDisabledState = AncestorDisabledStateUnknown;
     m_dataListAncestorState = Unknown;
     setNeedsWillValidateCheck();
     HTMLElement::insertedInto(insertionPoint);
     FormAssociatedElement::insertedInto(insertionPoint);
+
+    // Element addition can change validity of the form.

[keishi, 2014/10/03 03:44:13]

I think you'll find that Blink is light on comments. People often complain about
it, but it is a tradition carried over from WebKit. It is so we try to make the
code describe what we are doing so we don't need comments.

If we use HTMLFormElement::setNeedsValidityCheck() here, I think it will be more
clear that we are expecting  a validity change on the form and we won't need
this comment.

[Bartek Nowierski, 2014/10/03 06:01:33]

Done.

+    // Order form style recalculation (do it at the end to ensure that form
+    // owner is set).
+    setFormOwnerNeedsStyleRecalc();
+
     return InsertionDone;
 }
 
 void HTMLFormControlElement::removedFrom(ContainerNode* insertionPoint)
 {
+    // Element removal can definitely change validity of the form.
+    // Order form style recalculation (do it at the begining to ensure that
+    // form owner is still set).
+    setFormOwnerNeedsStyleRecalc();
+
     hideVisibleValidationMessage();
     m_hasValidationMessage = false;
     m_ancestorDisabledState = AncestorDisabledStateUnknown;
     m_dataListAncestorState = Unknown;
     HTMLElement::removedFrom(insertionPoint);
     FormAssociatedElement::removedFrom(insertionPoint);
 }
 
 void HTMLFormControlElement::setChangedSinceLastFormControlChangeEvent(bool changed)
 {
@@ skipping 191 matching lines @@
 {
     Page* page = document().page();
     if (!page)
         return 0;
 
     return &page->validationMessageClient();
 }
 
 bool HTMLFormControlElement::checkValidity(WillBeHeapVector<RefPtrWillBeMember<FormAssociatedElement> >* unhandledInvalidControls)
 {
-    if (!willValidate() || isValidFormControlElement())
+    if (!willValidate() || isValidElement())
         return true;
     // An event handler can deref this object.
     RefPtrWillBeRawPtr<HTMLFormControlElement> protector(this);
     RefPtrWillBeRawPtr<Document> originalDocument(document());
     bool needsDefaultAction = dispatchEvent(Event::createCancelable(EventTypeNames::invalid));
     if (needsDefaultAction && unhandledInvalidControls && inDocument() && originalDocument == document())
         unhandledInvalidControls->append(this);
     return false;
 }
 
-bool HTMLFormControlElement::isValidFormControlElement()
+bool HTMLFormControlElement::isValidElement()
 {
     // If the following assertion fails, setNeedsValidityCheck() is not called
     // correctly when something which changes validity is updated.
     ASSERT(m_isValid == valid());
     return m_isValid;
 }
 
 void HTMLFormControlElement::setNeedsValidityCheck()
 {
     bool newIsValid = valid();
     if (willValidate() && newIsValid != m_isValid) {
         // Update style for pseudo classes such as :valid :invalid.
+        // A change here could've affected the style of the form itself and
+        // other form elemetns, so recaluclate the entire form's subtree.
+        setFormOwnerNeedsStyleRecalc();
+        // Then recalculate the element itself (and its subtree), because
+        // it might not be in the tree of the owner form.
         setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::createWithExtraData(StyleChangeReason::PseudoClass, StyleChangeExtraData::Invalid));
     }
     m_isValid = newIsValid;
 
     // Updates only if this control already has a validation message.
     if (isValidationMessageVisible()) {
         // Calls updateVisibleValidationMessage() even if m_isValid is not
         // changed because a validation message can be changed.
         updateVisibleValidationMessage();
     }
@@ skipping 41 matching lines @@
 
 void HTMLFormControlElement::setFocus(bool flag)
 {
     LabelableElement::setFocus(flag);
 
     if (!flag && wasChangedSinceLastFormControlChangeEvent())
         dispatchFormControlChangeEvent();
 }
 
 } // namespace blink