Merge 116642

Source/WebCore/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 32 matching lines @@
 
 namespace WebCore {
 
 using namespace HTMLNames;
 using namespace std;
 
 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
     : LabelableElement(tagName, document)
     , m_fieldSetAncestor(0)
     , m_legendAncestor(0)
-    , m_ancestorsValid(false)
+    , m_fieldSetAncestorValid(false)
     , m_disabled(false)
     , m_readOnly(false)
     , m_required(false)
     , m_valueMatchesRenderer(false)
+    , m_dataListAncestorState(Unknown)
     , m_willValidateInitialized(false)
     , m_willValidate(true)
     , m_isValid(true)
     , m_wasChangedSinceLastFormControlChangeEvent(false)
     , m_hasAutofocused(false)
-    , m_hasDataListAncestor(false)
 {
     setForm(form ? form : findFormAncestor());
     setHasCustomWillOrDidRecalcStyle();
 }
 
 HTMLFormControlElement::~HTMLFormControlElement()
 {
 }
 
 void HTMLFormControlElement::detach()
@@ skipping 20 matching lines @@
 void HTMLFormControlElement::setFormMethod(const String& value)
 {
     setAttribute(formmethodAttr, value);
 }
 
 bool HTMLFormControlElement::formNoValidate() const
 {
     return fastHasAttribute(formnovalidateAttr);
 }
 
-void HTMLFormControlElement::updateAncestors() const
+void HTMLFormControlElement::updateFieldSetAndLegendAncestor() const
 {
     m_fieldSetAncestor = 0;
     m_legendAncestor = 0;
-    m_hasDataListAncestor = false;
     for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
         if (!m_legendAncestor && ancestor->hasTagName(legendTag))
             m_legendAncestor = static_cast<HTMLLegendElement*>(ancestor);
-        if (!m_fieldSetAncestor && ancestor->hasTagName(fieldsetTag))
+        if (ancestor->hasTagName(fieldsetTag)) {
             m_fieldSetAncestor = static_cast<HTMLFieldSetElement*>(ancestor);
-        if (!m_hasDataListAncestor && ancestor->hasTagName(datalistTag))
-            m_hasDataListAncestor = true;
-        if (m_hasDataListAncestor && m_fieldSetAncestor)
             break;
+        }
     }
-    m_ancestorsValid = true;
+    m_fieldSetAncestorValid = true;
 }
 
 void HTMLFormControlElement::parseAttribute(Attribute* attr)
 {
     if (attr->name() == formAttr)
         formAttributeChanged();
     else if (attr->name() == disabledAttr) {
         bool oldDisabled = m_disabled;
         m_disabled = !attr->isNull();
         if (oldDisabled != m_disabled)
@@ skipping 90 matching lines @@
 }
 
 void HTMLFormControlElement::didMoveToNewDocument(Document* oldDocument)
 {
     FormAssociatedElement::didMoveToNewDocument(oldDocument);
     HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
 Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(Node* insertionPoint)
 {
+    m_dataListAncestorState = Unknown;
+    setNeedsWillValidateCheck();
     HTMLElement::insertedInto(insertionPoint);
     FormAssociatedElement::insertedInto(insertionPoint);
-    m_ancestorsValid = false;
-    setNeedsWillValidateCheck();
     return InsertionDone;
 }
 
 void HTMLFormControlElement::removedFrom(Node* insertionPoint)
 {
+    m_fieldSetAncestorValid = false;
+    m_dataListAncestorState = Unknown;
     HTMLElement::removedFrom(insertionPoint);
     FormAssociatedElement::removedFrom(insertionPoint);
-    m_ancestorsValid = false;
 }
 
 const AtomicString& HTMLFormControlElement::formControlName() const
 {
     const AtomicString& name = getNameAttribute();
     return name.isNull() ? emptyAtom : name;
 }
 
 void HTMLFormControlElement::setName(const AtomicString& value)
 {
@@ skipping 20 matching lines @@
 {
     setChangedSinceLastFormControlChangeEvent(true);
     HTMLElement::dispatchInputEvent();
 }
 
 bool HTMLFormControlElement::disabled() const
 {
     if (m_disabled)
         return true;
 
-    if (!m_ancestorsValid)
-        updateAncestors();
+    if (!m_fieldSetAncestorValid)
+        updateFieldSetAndLegendAncestor();
 
     // Form controls in the first legend element inside a fieldset are not affected by fieldset.disabled.
     if (m_fieldSetAncestor && m_fieldSetAncestor->disabled())
         return !(m_legendAncestor && m_legendAncestor == m_fieldSetAncestor->legend());
     return false;
 }
 
 void HTMLFormControlElement::setDisabled(bool b)
 {
     setAttribute(disabledAttr, b ? "" : 0);
@@ skipping 58 matching lines @@
 }
 
 short HTMLFormControlElement::tabIndex() const
 {
     // Skip the supportsFocus check in HTMLElement.
     return Element::tabIndex();
 }
 
 bool HTMLFormControlElement::recalcWillValidate() const
 {
-    return !m_hasDataListAncestor && !m_disabled && !m_readOnly;
+    if (m_dataListAncestorState == Unknown) {
+        for (ContainerNode* ancestor = parentNode(); ancestor; ancestor = ancestor->parentNode()) {
+            if (!m_legendAncestor && ancestor->hasTagName(datalistTag)) {
+                m_dataListAncestorState = InsideDataList;
+                break;
+            }
+        }
+        if (m_dataListAncestorState == Unknown)
+            m_dataListAncestorState = NotInsideDataList;
+    }
+    return m_dataListAncestorState == NotInsideDataList && !m_disabled && !m_readOnly;
 }
 
 bool HTMLFormControlElement::willValidate() const
 {
-    if (!m_willValidateInitialized || !m_ancestorsValid) {
-        if (!m_ancestorsValid)
-            updateAncestors();
-
+    if (!m_willValidateInitialized || m_dataListAncestorState == Unknown) {
         m_willValidateInitialized = true;
         m_willValidate = recalcWillValidate();
     } else {
         // If the following assertion fails, setNeedsWillValidateCheck() is not
         // called correctly when something which changes recalcWillValidate() result
         // is updated.
         ASSERT(m_willValidate == recalcWillValidate());
     }
     return m_willValidate;
 }
 
 void HTMLFormControlElement::setNeedsWillValidateCheck()
 {
-    if (!m_ancestorsValid)
-        updateAncestors();
-
     // We need to recalculate willValidate immediately because willValidate change can causes style change.
     bool newWillValidate = recalcWillValidate();
     if (m_willValidateInitialized && m_willValidate == newWillValidate)
         return;
     m_willValidateInitialized = true;
     m_willValidate = newWillValidate;
     setNeedsStyleRecalc();
     if (!m_willValidate)
         hideVisibleValidationMessage();
 }
@@ skipping 107 matching lines @@
 HTMLFormControlElement* HTMLFormControlElement::enclosingFormControlElement(Node* node)
 {
     for (; node; node = node->parentNode()) {
         if (node->isElementNode() && toElement(node)->isFormControlElement())
             return static_cast<HTMLFormControlElement*>(node);
     }
     return 0;
 }
 
 } // namespace Webcore