Remove a lot of API surface from Element.

sky/engine/core/dom/Element.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003-2011, 2013, 2014 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
  * License as published by the Free Software Foundation; either
@@ skipping 41 matching lines @@
 class Image;
 class InputMethodContext;
 class IntSize;
 class Locale;
 class MutableStylePropertySet;
 class PropertySetCSSStyleDeclaration;
 class PseudoElement;
 class ShadowRoot;
 class StylePropertySet;
 
-enum AffectedSelectorType {
-    AffectedSelectorChecked = 1,
-    AffectedSelectorEnabled = 1 << 1,
-    AffectedSelectorDisabled = 1 << 2,
-    AffectedSelectorIndeterminate = 1 << 3,
-    AffectedSelectorLink = 1 << 4,
-    AffectedSelectorVisited = 1 << 5
-};
-typedef int AffectedSelectorMask;
-
 enum SpellcheckAttributeState {
     SpellcheckAttributeTrue,
     SpellcheckAttributeFalse,
     SpellcheckAttributeDefault
 };
 
 enum ElementFlags {
     TabIndexWasSetExplicitly = 1 << 0,
 
     NumberOfElementFlags = 2, // Required size of bitfield used to store the flags.
 };
 
 class Element : public ContainerNode {
     DEFINE_WRAPPERTYPEINFO();
 public:
     static PassRefPtr<Element> create(const QualifiedName&, Document*);
     virtual ~Element();
 
     bool hasAttribute(const QualifiedName&) const;
     const AtomicString& getAttribute(const QualifiedName&) const;
-
     Vector<RefPtr<Attr>> getAttributes();
+    bool hasAttributes() const;
+    bool hasAttribute(const AtomicString& name) const;
+    const AtomicString& getAttribute(const AtomicString& name) const;
+    void setAttribute(const AtomicString& name, const AtomicString& value, ExceptionState&);
+    void removeAttribute(const AtomicString& name);
+    void removeAttribute(const QualifiedName&);
 
     // Passing nullAtom as the second parameter removes the attribute when calling either of these set methods.
     void setAttribute(const QualifiedName&, const AtomicString& value);
     void setSynchronizedLazyAttribute(const QualifiedName&, const AtomicString& value);
 
-    void removeAttribute(const QualifiedName&);
-
     // Typed getters and setters for language bindings.
     int getIntegralAttribute(const QualifiedName& attributeName) const;
     void setIntegralAttribute(const QualifiedName& attributeName, int value);
     unsigned getUnsignedIntegralAttribute(const QualifiedName& attributeName) const;
     void setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value);
     double getFloatingPointAttribute(const QualifiedName& attributeName, double fallbackValue = std::numeric_limits<double>::quiet_NaN()) const;
     void setFloatingPointAttribute(const QualifiedName& attributeName, double value);
 
-    bool hasAttributes() const;
-
-    bool hasAttribute(const AtomicString& name) const;
-
-    const AtomicString& getAttribute(const AtomicString& name) const;
-
-    void setAttribute(const AtomicString& name, const AtomicString& value, ExceptionState&);
-    static bool parseAttributeName(QualifiedName&, const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState&);
-
     const AtomicString& getIdAttribute() const;
     void setIdAttribute(const AtomicString&);
 
     const AtomicString& getClassAttribute() const;
 
     // Call this to get the value of the id attribute for style resolution purposes.
     // The value will already be lowercased if the document is in compatibility mode,
     // so this function is not suitable for non-style uses.
     const AtomicString& idForStyleResolution() const;
 
@@ skipping 26 matching lines @@
     void setScrollTop(int);
     void setScrollTop(const Dictionary& scrollOptionsVertical, ExceptionState&);
     int scrollWidth();
     int scrollHeight();
 
     PassRefPtr<ClientRectList> getClientRects();
     PassRefPtr<ClientRect> getBoundingClientRect();
 
     virtual void didMoveToNewDocument(Document&) override;
 
-    void removeAttribute(const AtomicString& name);
-
     CSSStyleDeclaration* style();
 
     const QualifiedName& tagQName() const { return m_tagName; }
     String tagName() const { return nodeName(); }
 
     bool hasTagName(const QualifiedName& tagName) const { return m_tagName == tagName; }
     bool hasTagName(const HTMLQualifiedName& tagName) const { return ContainerNode::hasTagName(tagName); }
 
     // A fast function for checking the local name against another atomic string.
     bool hasLocalName(const AtomicString& other) const { return m_tagName.localName() == other; }
@@ skipping 17 matching lines @@
     bool removeInlineStyleProperty(CSSPropertyID);
     void removeAllInlineStyleProperties();
 
     void synchronizeStyleAttributeInternal() const;
 
     enum AttributeModificationReason {
         ModifiedDirectly,
         ModifiedByCloning
     };
 
-    virtual void attributeChanged(const QualifiedName&, const AtomicString&, AttributeModificationReason = ModifiedDirectly);
     virtual void parseAttribute(const QualifiedName&, const AtomicString&);
 
     virtual bool hasLegalLinkAttribute(const QualifiedName&) const;
     virtual const QualifiedName& subResourceAttributeName() const;
 
     // Only called by the parser immediately after element construction.
     void parserSetAttributes(const Vector<Attribute>&);
 
-    // Remove attributes that might introduce scripting from the vector leaving the element unchanged.
-    void stripScriptingAttributes(Vector<Attribute>&) const;
-
     bool sharesSameElementData(const Element& other) const { return elementData() == other.elementData(); }
 
     // Clones attributes only.
     void cloneAttributesFromElement(const Element&);
 
     // Clones all attribute-derived data, including subclass specifics (through copyNonAttributeProperties.)
     void cloneDataFromElement(const Element&);
 
     bool hasEquivalentAttributes(const Element* other) const;
 
     virtual void attach(const AttachContext& = AttachContext()) override;
     virtual void detach(const AttachContext& = AttachContext()) override;
     virtual RenderObject* createRenderer(RenderStyle*);
     virtual bool rendererIsNeeded(const RenderStyle&);
     void recalcStyle(StyleRecalcChange, Text* nextTextSibling = 0);
-    void didAffectSelector(AffectedSelectorMask);
     void setAnimationStyleChange(bool);
     void setNeedsAnimationStyleRecalc();
 
     void setNeedsCompositingUpdate();
 
     bool supportsStyleSharing() const;
 
     ElementShadow* shadow() const;
     ElementShadow& ensureShadow();
     PassRefPtr<ShadowRoot> createShadowRoot(ExceptionState&);
     ShadowRoot* shadowRoot() const;
     ShadowRoot* youngestShadowRoot() const;
 
     bool hasAuthorShadowRoot() const { return shadowRoot(); }
 
-    bool isInDescendantTreeOf(const Element* shadowHost) const;
-
     RenderStyle* computedStyle(PseudoId = NOPSEUDO);
 
     bool isUpgradedCustomElement() { return customElementState() == Upgraded; }
     bool isUnresolvedCustomElement() { return customElementState() == WaitingForUpgrade; }
 
     AtomicString computeInheritedLanguage() const;
     Locale& locale() const;
 
     virtual void accessKeyAction(bool /*sendToAnyEvent*/) { }
 
     virtual bool isURLAttribute(const Attribute&) const { return false; }
-    virtual bool isHTMLContentAttribute(const Attribute&) const { return false; }
 
     virtual bool isLiveLink() const { return false; }
     KURL hrefURL() const;
 
     KURL getURLAttribute(const QualifiedName&) const;
     KURL getNonEmptyURLAttribute(const QualifiedName&) const;
 
     virtual const AtomicString imageSourceURL() const;
     virtual Image* imageContents() { return 0; }
 
     void focus(bool restorePreviousSelection = true, FocusType = FocusTypeNone);
     void updateFocusAppearance(bool restorePreviousSelection);
     void blur();
     // Whether this element can receive focus at all. Most elements are not
     // focusable but some elements, such as form controls and links, are. Unlike
     // rendererIsFocusable(), this method may be called when layout is not up to
     // date, so it must not use the renderer to determine focusability.
     virtual bool supportsFocus() const;
     // Whether the node can actually be focused.
     bool isFocusable() const;
-    virtual bool isKeyboardFocusable() const;
+    bool isKeyboardFocusable() const;
     virtual bool isMouseFocusable() const;
     virtual void willCallDefaultEventHandler(const Event&) override final;
-    virtual void dispatchFocusEvent(Element* oldFocusedElement, FocusType);
-    virtual void dispatchBlurEvent(Element* newFocusedElement);
+    void dispatchFocusEvent(Element* oldFocusedElement, FocusType);
+    void dispatchBlurEvent(Element* newFocusedElement);
     void dispatchFocusInEvent(const AtomicString& eventType, Element* oldFocusedElement);
     void dispatchFocusOutEvent(const AtomicString& eventType, Element* newFocusedElement);
 
-    String innerText();
-    String outerText();
-
-    String textFromChildren();
-
     virtual String title() const { return String(); }
 
     LayoutSize minimumSizeForResizing() const;
     void setMinimumSizeForResizing(const LayoutSize&);
 
     // Called by the parser when this element's close tag is reached,
     // signaling that all child tags have been parsed and added.
     // This is needed for <applet> and <object> elements, which can't lay themselves out
     // until they know all of their nested <param>s. [Radar 3603191, 4040848].
     // Also used for script elements and some SVG elements for similar purposes,
     // but making parsing a special case in this respect should be avoided if possible.
-    virtual void finishParsingChildren();
+    virtual void finishParsingChildren() { }
 
-    void beginParsingChildren() { setIsFinishedParsingChildren(false); }
-
-    virtual bool matchesReadOnlyPseudoClass() const { return false; }
-    virtual bool matchesReadWritePseudoClass() const { return false; }
     bool matches(const String& selectors, ExceptionState&);
-    virtual bool shouldAppearIndeterminate() const { return false; }
 
     DOMTokenList& classList();
 
     virtual bool canContainRangeEndPoint() const override { return true; }
 
     void setCustomElementDefinition(PassRefPtr<CustomElementDefinition>);
     CustomElementDefinition* customElementDefinition() const;
 
     bool isSpellCheckingEnabled() const;
 
@@ skipping 15 matching lines @@
     bool hasInputMethodContext() const;
 
     void synchronizeAttribute(const AtomicString& localName) const;
 
     MutableStylePropertySet& ensureMutableInlineStyle();
     void clearMutableInlineStyleIfEmpty();
 
     void setTabIndex(int);
     virtual short tabIndex() const override;
 
-    virtual void trace(Visitor*) override;
+    String textFromChildren();
 
 protected:
     Element(const QualifiedName& tagName, Document*, ConstructionType);
 
     const ElementData* elementData() const { return m_elementData.get(); }
     UniqueElementData& ensureUniqueElementData();
 
     virtual InsertionNotificationRequest insertedInto(ContainerNode*) override;
     virtual void removedFrom(ContainerNode*) override;
     virtual void childrenChanged(const ChildrenChange&) override;
@@ skipping 16 matching lines @@
     virtual void setWasFocusedByMouse(bool) { }
 
     // classAttributeChanged() exists to share code between
     // parseAttribute (called via setAttribute()) and
     // svgAttributeChanged (called when element.className.baseValue is set)
     void classAttributeChanged(const AtomicString& newClassString);
 
     PassRefPtr<RenderStyle> originalStyleForRenderer();
 
 private:
+    void attributeChanged(const QualifiedName&, const AtomicString&, AttributeModificationReason = ModifiedDirectly);
+
     bool hasElementFlag(ElementFlags mask) const { return hasRareData() && hasElementFlagInternal(mask); }
     void setElementFlag(ElementFlags, bool value = true);
     void clearElementFlag(ElementFlags);
     bool hasElementFlagInternal(ElementFlags) const;
 
     bool isElementNode() const = delete; // This will catch anyone doing an unnecessary check.
     bool isDocumentFragment() const = delete; // This will catch anyone doing an unnecessary check.
     bool isDocumentNode() const = delete; // This will catch anyone doing an unnecessary check.
 
     void styleAttributeChanged(const AtomicString& newStyleString);
@@ skipping 246 matching lines @@
     static PassRefPtr<T> create(const QualifiedName&, Document&)
 #define DEFINE_ELEMENT_FACTORY_WITH_TAGNAME(T) \
     PassRefPtr<T> T::create(const QualifiedName& tagName, Document& document) \
     { \
         return adoptRef(new T(tagName, document)); \
     }
 
 } // namespace
 
 #endif // Element_h