Add an argument indicating the type of insertion to Node::insertedInto
[WebKit-https.git] / Source / WebCore / html / HTMLFormControlElement.h
index b3a9354..2be9a91 100644 (file)
@@ -2,7 +2,7 @@
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  *
  */
 
-#ifndef HTMLFormControlElement_h
-#define HTMLFormControlElement_h
+#pragma once
 
+#include "Autofill.h"
 #include "FormAssociatedElement.h"
 #include "LabelableElement.h"
 
+#if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
+#include "Autocapitalize.h"
+#endif
+
 namespace WebCore {
 
-class FormDataList;
+class DOMFormData;
 class HTMLFieldSetElement;
 class HTMLFormElement;
 class HTMLLegendElement;
 class ValidationMessage;
-class ValidityState;
 
 // HTMLFormControlElement is the default implementation of FormAssociatedElement,
 // and form-associated element implementations should use HTMLFormControlElement
@@ -43,119 +46,147 @@ class HTMLFormControlElement : public LabelableElement, public FormAssociatedEle
 public:
     virtual ~HTMLFormControlElement();
 
-    HTMLFormElement* form() const { return FormAssociatedElement::form(); }
+    HTMLFormElement* form() const final { return FormAssociatedElement::form(); }
 
-    String formEnctype() const;
-    void setFormEnctype(const String&);
-    String formMethod() const;
-    void setFormMethod(const String&);
+    WEBCORE_EXPORT String formEnctype() const;
+    WEBCORE_EXPORT void setFormEnctype(const String&);
+    WEBCORE_EXPORT String formMethod() const;
+    WEBCORE_EXPORT void setFormMethod(const String&);
     bool formNoValidate() const;
+    WEBCORE_EXPORT String formAction() const;
+    WEBCORE_EXPORT void setFormAction(const AtomicString&);
 
-    void ancestorDisabledStateWasChanged();
+    void setAncestorDisabled(bool isDisabled);
 
     virtual void reset() { }
 
-    virtual bool formControlValueMatchesRenderer() const { return m_valueMatchesRenderer; }
-    virtual void setFormControlValueMatchesRenderer(bool b) { m_valueMatchesRenderer = b; }
+    bool formControlValueMatchesRenderer() const { return m_valueMatchesRenderer; }
+    void setFormControlValueMatchesRenderer(bool b) { m_valueMatchesRenderer = b; }
 
-    virtual bool wasChangedSinceLastFormControlChangeEvent() const;
-    virtual void setChangedSinceLastFormControlChangeEvent(bool);
+    bool wasChangedSinceLastFormControlChangeEvent() const { return m_wasChangedSinceLastFormControlChangeEvent; }
+    void setChangedSinceLastFormControlChangeEvent(bool);
 
     virtual void dispatchFormControlChangeEvent();
-    virtual void dispatchFormControlInputEvent();
-
-    virtual bool disabled() const;
-    void setDisabled(bool);
+    void dispatchChangeEvent();
+    void dispatchFormControlInputEvent();
 
-    virtual bool isFocusable() const;
-    virtual bool isEnumeratable() const { return false; }
+    bool isDisabledFormControl() const override;
 
-    // Determines whether or not a control will be automatically focused.
-    virtual bool autofocus() const;
+    bool isFocusable() const override;
+    bool isEnumeratable() const override { return false; }
 
-    bool required() const;
+    bool isRequired() const;
 
     const AtomicString& type() const { return formControlType(); }
 
-    virtual const AtomicString& formControlType() const OVERRIDE = 0;
-    virtual bool isEnabledFormControl() const { return !disabled(); }
-    virtual bool isReadOnlyFormControl() const { return readOnly(); }
+    virtual const AtomicString& formControlType() const = 0;
 
     virtual bool canTriggerImplicitSubmission() const { return false; }
 
     // Override in derived classes to get the encoded name=value pair for submitting.
     // Return true for a successful control (see HTML4-17.13.2).
-    virtual bool appendFormData(FormDataList&, bool) { return false; }
+    bool appendFormData(DOMFormData&, bool) override { return false; }
 
     virtual bool isSuccessfulSubmitButton() const { return false; }
     virtual bool isActivatedSubmit() const { return false; }
     virtual void setActivatedSubmit(bool) { }
 
-    virtual bool willValidate() const;
+#if ENABLE(IOS_AUTOCORRECT_AND_AUTOCAPITALIZE)
+    WEBCORE_EXPORT bool shouldAutocorrect() const final;
+    WEBCORE_EXPORT AutocapitalizeType autocapitalizeType() const final;
+#endif
+
+    WEBCORE_EXPORT bool willValidate() const final;
     void updateVisibleValidationMessage();
     void hideVisibleValidationMessage();
-    bool checkValidity(Vector<RefPtr<FormAssociatedElement> >* unhandledInvalidControls = 0);
+    WEBCORE_EXPORT bool checkValidity(Vector<RefPtr<HTMLFormControlElement>>* unhandledInvalidControls = nullptr);
+    bool reportValidity();
+    void focusAndShowValidationMessage();
+    bool isShowingValidationMessage() const;
     // This must be called when a validation constraint or control value is changed.
-    void setNeedsValidityCheck();
-    virtual void setCustomValidity(const String&) OVERRIDE;
+    void updateValidity();
+    void setCustomValidity(const String&) override;
 
-    bool readOnly() const { return m_readOnly; }
+    bool isReadOnly() const { return m_isReadOnly; }
+    bool isDisabledOrReadOnly() const { return isDisabledFormControl() || m_isReadOnly; }
 
     bool hasAutofocused() { return m_hasAutofocused; }
     void setAutofocused() { m_hasAutofocused = true; }
 
     static HTMLFormControlElement* enclosingFormControlElement(Node*);
 
+    WEBCORE_EXPORT String autocomplete() const;
+    WEBCORE_EXPORT void setAutocomplete(const String&);
+
+    AutofillMantle autofillMantle() const;
+
+    WEBCORE_EXPORT AutofillData autofillData() const;
+
     using Node::ref;
     using Node::deref;
 
 protected:
-    HTMLFormControlElement(const QualifiedName& tagName, Document*, HTMLFormElement*);
+    HTMLFormControlElement(const QualifiedName& tagName, Document&, HTMLFormElement*);
 
-    virtual void parseAttribute(const Attribute&) OVERRIDE;
-    virtual void requiredAttributeChanged();
+    bool disabledByAncestorFieldset() const { return m_disabledByAncestorFieldset; }
+
+    void parseAttribute(const QualifiedName&, const AtomicString&) override;
     virtual void disabledAttributeChanged();
-    virtual void attach();
-    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
-    virtual void removedFrom(ContainerNode*) OVERRIDE;
-    virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
+    virtual void disabledStateChanged();
+    virtual void readOnlyAttributeChanged();
+    virtual void requiredAttributeChanged();
+    void didAttachRenderers() override;
+    InsertedIntoResult insertedInto(InsertionType, ContainerNode&) override;
+    void didFinishInsertingNode() override;
+    void removedFrom(ContainerNode&) override;
+    void didMoveToNewDocument(Document& oldDocument, Document& newDocument) override;
 
-    virtual bool supportsFocus() const;
-    virtual bool isKeyboardFocusable(KeyboardEvent*) const;
-    virtual bool isMouseFocusable() const;
+    bool supportsFocus() const override;
+    bool isKeyboardFocusable(KeyboardEvent&) const override;
+    bool isMouseFocusable() const override;
 
-    virtual void didRecalcStyle(StyleChange) OVERRIDE;
+    void didRecalcStyle(Style::Change) override;
 
-    virtual void dispatchBlurEvent(PassRefPtr<Node> newFocusedNode);
+    void dispatchBlurEvent(RefPtr<Element>&& newFocusedElement) override;
 
     // This must be called any time the result of willValidate() has changed.
     void setNeedsWillValidateCheck();
-    virtual bool recalcWillValidate() const;
+    virtual bool computeWillValidate() const;
+
+    bool validationMessageShadowTreeContains(const Node&) const;
+
+    void willChangeForm() override;
+    void didChangeForm() override;
 
 private:
-    virtual void refFormAssociatedElement() { ref(); }
-    virtual void derefFormAssociatedElement() { deref(); }
+    void refFormAssociatedElement() override { ref(); }
+    void derefFormAssociatedElement() override { deref(); }
 
-    virtual bool isFormControlElement() const { return true; }
+    bool matchesValidPseudoClass() const override;
+    bool matchesInvalidPseudoClass() const override;
 
-    virtual short tabIndex() const;
+    bool isFormControlElement() const final { return true; }
+    bool alwaysCreateUserAgentShadowRoot() const override { return true; }
 
-    virtual HTMLFormElement* virtualForm() const;
-    virtual bool isDefaultButtonForForm() const;
-    virtual bool isValidFormControlElement();
-    String visibleValidationMessage() const;
-    void updateAncestorDisabledState() const;
+    int tabIndex() const final;
 
-    OwnPtr<ValidationMessage> m_validationMessage;
-    bool m_disabled : 1;
-    bool m_readOnly : 1;
-    bool m_required : 1;
-    bool m_valueMatchesRenderer : 1;
+    bool isValidFormControlElement() const;
+
+    bool computeIsDisabledByFieldsetAncestor() const;
+
+    HTMLElement& asHTMLElement() final { return *this; }
+    const HTMLFormControlElement& asHTMLElement() const final { return *this; }
+    HTMLFormControlElement* asFormNamedItem() final { return this; }
+
+    std::unique_ptr<ValidationMessage> m_validationMessage;
+    unsigned m_disabled : 1;
+    unsigned m_isReadOnly : 1;
+    unsigned m_isRequired : 1;
+    unsigned m_valueMatchesRenderer : 1;
+    unsigned m_disabledByAncestorFieldset : 1;
 
-    enum AncestorDisabledState { AncestorDisabledStateUnknown, AncestorDisabledStateEnabled, AncestorDisabledStateDisabled };
-    mutable AncestorDisabledState m_ancestorDisabledState;
     enum DataListAncestorState { Unknown, InsideDataList, NotInsideDataList };
-    mutable enum DataListAncestorState m_dataListAncestorState;
+    mutable unsigned m_dataListAncestorState : 2;
 
     // The initial value of m_willValidate depends on the derived class. We can't
     // initialize it with a virtual function in the constructor. m_willValidate
@@ -165,13 +196,17 @@ private:
 
     // Cache of validity()->valid().
     // But "candidate for constraint validation" doesn't affect m_isValid.
-    bool m_isValid : 1;
+    unsigned m_isValid : 1;
 
-    bool m_wasChangedSinceLastFormControlChangeEvent : 1;
+    unsigned m_wasChangedSinceLastFormControlChangeEvent : 1;
 
-    bool m_hasAutofocused : 1;
+    unsigned m_hasAutofocused : 1;
 };
 
-} // namespace
+} // namespace WebCore
 
-#endif
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::HTMLFormControlElement)
+    static bool isType(const WebCore::Element& element) { return element.isFormControlElement(); }
+    static bool isType(const WebCore::Node& node) { return is<WebCore::Element>(node) && isType(downcast<WebCore::Element>(node)); }
+    static bool isType(const WebCore::FormAssociatedElement& element) { return element.isFormControlElement(); }
+SPECIALIZE_TYPE_TRAITS_END()