Simplify relationship between Attr and Element now that Attr is childless
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2017 22:25:43 +0000 (22:25 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2017 22:25:43 +0000 (22:25 +0000)
https://bugs.webkit.org/show_bug.cgi?id=171909

Reviewed by Ryosuke Niwa.

Source/WebCore:

Simplify relationship between Attr and Element now that Attr is childless
after r216259.

No new tests, no Web facing behavior change.

* dom/Attr.cpp:
(WebCore::Attr::setValue):
Attr::setValue() was only called by Element::setAttributeInternal() to make sure
we updated the Attr node's Text child. However, now that Attr has no Text child,
Element no longer needs to update the Attr node's value.
Attr::setValueForBindings() was thus renamed to setValue(). Its implementation
was also simplified by calling Element::setAttribute() on its ownerElement, if
it has one, instead of duplicating a bunch of code from Element::setAttributeInternal().

(WebCore::Attr::setNodeValue):
Call setValue() instead of setValueForBindings() now that it has been renamed.

* dom/Attr.h:
* dom/Attr.idl:
Rename valueForBindings / setValueForBindings to value / setValue.

* dom/Document.h:
Split shouldInvalidateNodeListAndCollectionCaches() into 2 methods, one taking an Attr name
and another that does not. There are now 2 calls sites instead of one, so we no longer need
to branch in this function.

* dom/Element.cpp:
(WebCore::Element::setAttributeInternal):
Drop code calling Attr::setValue() on the Attr node since Attr::setValue() was only
duplicating logic from Element::setAttributeInternal() after r216259. There is nothing
on Attr that needs updating when an element attribute gets updated.

(WebCore::Element::attributeChanged):
Call the new invalidateNodeListAndCollectionCachesInAncestorsForAttribute(). This
is the only call site that passes an attribute name.

* dom/Node.cpp:
(WebCore::Document::shouldInvalidateNodeListAndCollectionCaches):
(WebCore::Document::shouldInvalidateNodeListAndCollectionCachesForAttribute):
Split into 2 to avoid branching, as explained above.

(WebCore::Node::invalidateNodeListAndCollectionCachesInAncestors):
(WebCore::Node::invalidateNodeListAndCollectionCachesInAncestorsForAttribute):
- invalidateNodeListAndCollectionCachesInAncestors() used to invalidate childNodeLists
  if the Node was an attribute node. Drop this as this is no longer needed as of r216259.
- After the change to Attr::setValue(), call sites for
  invalidateNodeListAndCollectionCachesInAncestors() either had no parameters, or both
  parameters present and non-null. There is therefore no longer any need to handle
  having an attrName but no attributeOwnerElement. To make this obvious, I split this
  into 2 methods: invalidateNodeListAndCollectionCachesInAncestors() and
  invalidateNodeListAndCollectionCachesInAncestorsForAttribute(attrName). We no longer
  need the attributeOwnerElement parameter as it was only used to exit early.

* dom/Node.h:

Source/WebKit/mac:

Build fix.

* DOM/DOMAttr.mm:
(-[DOMAttr value]):
(-[DOMAttr setValue:]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@216632 268f45cc-cd09-0410-ab3c-d52691b4dbfc

19 files changed:
Source/WebCore/ChangeLog
Source/WebCore/dom/Attr.cpp
Source/WebCore/dom/Attr.h
Source/WebCore/dom/Attr.idl
Source/WebCore/dom/Document.h
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/LiveNodeList.h
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/Node.h
Source/WebCore/dom/NodeRareData.h
Source/WebCore/html/CachedHTMLCollection.h
Source/WebCore/html/HTMLCollection.cpp
Source/WebCore/html/HTMLCollection.h
Source/WebCore/html/HTMLFormControlsCollection.cpp
Source/WebCore/html/HTMLFormControlsCollection.h
Source/WebCore/html/HTMLSelectElement.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/DOM/DOMAttr.mm
Source/WebKit2/WebProcess/InjectedBundle/API/gtk/DOM/WebKitDOMAttr.cpp

index 3c8fe66..81c968b 100644 (file)
@@ -1,3 +1,65 @@
+2017-05-10  Chris Dumez  <cdumez@apple.com>
+
+        Simplify relationship between Attr and Element now that Attr is childless
+        https://bugs.webkit.org/show_bug.cgi?id=171909
+
+        Reviewed by Ryosuke Niwa.
+
+        Simplify relationship between Attr and Element now that Attr is childless
+        after r216259.
+
+        No new tests, no Web facing behavior change.
+
+        * dom/Attr.cpp:
+        (WebCore::Attr::setValue):
+        Attr::setValue() was only called by Element::setAttributeInternal() to make sure
+        we updated the Attr node's Text child. However, now that Attr has no Text child,
+        Element no longer needs to update the Attr node's value.
+        Attr::setValueForBindings() was thus renamed to setValue(). Its implementation
+        was also simplified by calling Element::setAttribute() on its ownerElement, if
+        it has one, instead of duplicating a bunch of code from Element::setAttributeInternal().
+
+        (WebCore::Attr::setNodeValue):
+        Call setValue() instead of setValueForBindings() now that it has been renamed.
+
+        * dom/Attr.h:
+        * dom/Attr.idl:
+        Rename valueForBindings / setValueForBindings to value / setValue.
+
+        * dom/Document.h:
+        Split shouldInvalidateNodeListAndCollectionCaches() into 2 methods, one taking an Attr name
+        and another that does not. There are now 2 calls sites instead of one, so we no longer need
+        to branch in this function.
+
+        * dom/Element.cpp:
+        (WebCore::Element::setAttributeInternal):
+        Drop code calling Attr::setValue() on the Attr node since Attr::setValue() was only
+        duplicating logic from Element::setAttributeInternal() after r216259. There is nothing
+        on Attr that needs updating when an element attribute gets updated.
+
+        (WebCore::Element::attributeChanged):
+        Call the new invalidateNodeListAndCollectionCachesInAncestorsForAttribute(). This
+        is the only call site that passes an attribute name.
+
+        * dom/Node.cpp:
+        (WebCore::Document::shouldInvalidateNodeListAndCollectionCaches):
+        (WebCore::Document::shouldInvalidateNodeListAndCollectionCachesForAttribute):
+        Split into 2 to avoid branching, as explained above.
+
+        (WebCore::Node::invalidateNodeListAndCollectionCachesInAncestors):
+        (WebCore::Node::invalidateNodeListAndCollectionCachesInAncestorsForAttribute):
+        - invalidateNodeListAndCollectionCachesInAncestors() used to invalidate childNodeLists
+          if the Node was an attribute node. Drop this as this is no longer needed as of r216259.
+        - After the change to Attr::setValue(), call sites for
+          invalidateNodeListAndCollectionCachesInAncestors() either had no parameters, or both
+          parameters present and non-null. There is therefore no longer any need to handle
+          having an attrName but no attributeOwnerElement. To make this obvious, I split this
+          into 2 methods: invalidateNodeListAndCollectionCachesInAncestors() and
+          invalidateNodeListAndCollectionCachesInAncestorsForAttribute(attrName). We no longer
+          need the attributeOwnerElement parameter as it was only used to exit early.
+
+        * dom/Node.h:
+
 2017-05-10  Antti Koivisto  <antti@apple.com>
 
         REGRESSION (r207372) Visibility property is not inherited when used in an animation
index 0a4dc48..c8ffebe 100644 (file)
@@ -86,28 +86,15 @@ ExceptionOr<void> Attr::setPrefix(const AtomicString& prefix)
 
 void Attr::setValue(const AtomicString& value)
 {
-    if (m_element) {
-        Style::AttributeChangeInvalidation styleInvalidation(*m_element, qualifiedName(), elementAttribute().value(), value);
-        elementAttribute().setValue(value);
-    } else
-        m_standaloneValue = value;
-
-    invalidateNodeListAndCollectionCachesInAncestors(&m_name, m_element);
-}
-
-void Attr::setValueForBindings(const AtomicString& value)
-{
-    AtomicString oldValue = this->value();
     if (m_element)
-        m_element->willModifyAttribute(qualifiedName(), oldValue, value);
-    setValue(value);
-    if (m_element)
-        m_element->didModifyAttribute(qualifiedName(), oldValue, value);
+        m_element->setAttribute(qualifiedName(), value);
+    else
+        m_standaloneValue = value;
 }
 
 ExceptionOr<void> Attr::setNodeValue(const String& value)
 {
-    setValueForBindings(value);
+    setValue(value);
     return { };
 }
 
index 72a60b6..4d9c658 100644 (file)
@@ -44,9 +44,7 @@ public:
     Element* ownerElement() const { return m_element; }
 
     WEBCORE_EXPORT const AtomicString& value() const;
-    void setValue(const AtomicString&);
-    const AtomicString& valueForBindings() const { return value(); }
-    WEBCORE_EXPORT void setValueForBindings(const AtomicString&);
+    WEBCORE_EXPORT void setValue(const AtomicString&);
 
     const QualifiedName& qualifiedName() const { return m_name; }
 
index b093511..43f860f 100644 (file)
@@ -27,7 +27,7 @@
     readonly attribute DOMString? prefix;
     readonly attribute DOMString localName;
     readonly attribute DOMString name;
-    [CEReactions, ImplementedAs=valueForBindings] attribute DOMString value;
+    [CEReactions] attribute DOMString value;
 
     readonly attribute Element? ownerElement;
 
index 8cc9067..ab8a4da 100644 (file)
@@ -726,8 +726,11 @@ public:
     void unregisterCollection(HTMLCollection&);
     void collectionCachedIdNameMap(const HTMLCollection&);
     void collectionWillClearIdNameMap(const HTMLCollection&);
-    bool shouldInvalidateNodeListAndCollectionCaches(const QualifiedName* attrName = nullptr) const;
-    void invalidateNodeListAndCollectionCaches(const QualifiedName* attrName);
+    bool shouldInvalidateNodeListAndCollectionCaches() const;
+    bool shouldInvalidateNodeListAndCollectionCachesForAttribute(const QualifiedName& attrName) const;
+
+    template <typename InvalidationFunction>
+    void invalidateNodeListAndCollectionCaches(InvalidationFunction);
 
     void attachNodeIterator(NodeIterator*);
     void detachNodeIterator(NodeIterator*);
index ec7d184..f71bacc 100644 (file)
@@ -1276,15 +1276,8 @@ inline void Element::setAttributeInternal(unsigned index, const QualifiedName& n
     willModifyAttribute(attributeName, oldValue, newValue);
 
     if (newValue != oldValue) {
-        // If there is an Attr node hooked to this attribute, the Attr::setValue() call below
-        // will write into the ElementData.
-        // FIXME: Refactor this so it makes some sense.
-        if (RefPtr<Attr> attrNode = attrIfExists(attributeName))
-            attrNode->setValue(newValue);
-        else {
-            Style::AttributeChangeInvalidation styleInvalidation(*this, name, oldValue, newValue);
-            ensureUniqueElementData().attributeAt(index).setValue(newValue);
-        }
+        Style::AttributeChangeInvalidation styleInvalidation(*this, name, oldValue, newValue);
+        ensureUniqueElementData().attributeAt(index).setValue(newValue);
     }
 
     didModifyAttribute(attributeName, oldValue, newValue);
@@ -1340,7 +1333,7 @@ void Element::attributeChanged(const QualifiedName& name, const AtomicString& ol
     if (valueIsSameAsBefore)
         return;
 
-    invalidateNodeListAndCollectionCachesInAncestors(&name, this);
+    invalidateNodeListAndCollectionCachesInAncestorsForAttribute(name);
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->handleAttributeChanged(name, this);
index 415d190..33f813d 100644 (file)
@@ -48,12 +48,13 @@ public:
 
     ALWAYS_INLINE NodeListInvalidationType invalidationType() const { return static_cast<NodeListInvalidationType>(m_invalidationType); }
     ContainerNode& ownerNode() const { return m_ownerNode; }
-    ALWAYS_INLINE void invalidateCacheForAttribute(const QualifiedName* attrName) const
+    ALWAYS_INLINE void invalidateCacheForAttribute(const QualifiedName& attrName) const
     {
-        if (!attrName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attrName))
-            invalidateCache(document());
+        if (shouldInvalidateTypeOnAttributeChange(invalidationType(), attrName))
+            invalidateCache();
     }
-    virtual void invalidateCache(Document&) const = 0;
+    virtual void invalidateCacheForDocument(Document&) const = 0;
+    void invalidateCache() const { invalidateCacheForDocument(document()); }
 
     bool isRegisteredForInvalidationAtDocument() const { return m_isRegisteredForInvalidationAtDocument; }
     void setRegisteredForInvalidationAtDocument(bool f) { m_isRegisteredForInvalidationAtDocument = f; }
@@ -89,7 +90,7 @@ public:
     bool collectionCanTraverseBackward() const { return true; }
     void willValidateIndexCache() const { document().registerNodeListForInvalidation(const_cast<CachedLiveNodeList<NodeListType>&>(*this)); }
 
-    void invalidateCache(Document&) const final;
+    void invalidateCacheForDocument(Document&) const final;
     size_t memoryCost() const final { return m_indexCache.memoryCost(); }
 
 protected:
@@ -152,7 +153,7 @@ inline ContainerNode& CachedLiveNodeList<NodeListType>::rootNode() const
 }
 
 template <class NodeListType>
-void CachedLiveNodeList<NodeListType>::invalidateCache(Document& document) const
+void CachedLiveNodeList<NodeListType>::invalidateCacheForDocument(Document& document) const
 {
     if (!m_indexCache.hasValidCache(nodeList()))
         return;
index 96f2eb1..7f8e0cf 100644 (file)
@@ -838,54 +838,74 @@ bool shouldInvalidateNodeListCachesForAttr<numNodeListInvalidationTypes>(const u
     return false;
 }
 
-bool Document::shouldInvalidateNodeListAndCollectionCaches(const QualifiedName* attrName) const
+inline bool Document::shouldInvalidateNodeListAndCollectionCaches() const
 {
-    if (attrName)
-        return shouldInvalidateNodeListCachesForAttr<DoNotInvalidateOnAttributeChanges + 1>(m_nodeListAndCollectionCounts, *attrName);
-
-    for (int type = 0; type < numNodeListInvalidationTypes; type++) {
+    for (int type = 0; type < numNodeListInvalidationTypes; ++type) {
         if (m_nodeListAndCollectionCounts[type])
             return true;
     }
-
     return false;
 }
 
-void Document::invalidateNodeListAndCollectionCaches(const QualifiedName* attrName)
+inline bool Document::shouldInvalidateNodeListAndCollectionCachesForAttribute(const QualifiedName& attrName) const
+{
+    return shouldInvalidateNodeListCachesForAttr<DoNotInvalidateOnAttributeChanges + 1>(m_nodeListAndCollectionCounts, attrName);
+}
+
+template <typename InvalidationFunction>
+void Document::invalidateNodeListAndCollectionCaches(InvalidationFunction invalidate)
 {
     Vector<LiveNodeList*, 8> lists;
     copyToVector(m_listsInvalidatedAtDocument, lists);
     for (auto* list : lists)
-        list->invalidateCacheForAttribute(attrName);
+        invalidate(*list);
 
     Vector<HTMLCollection*, 8> collections;
     copyToVector(m_collectionsInvalidatedAtDocument, collections);
     for (auto* collection : collections)
-        collection->invalidateCacheForAttribute(attrName);
+        invalidate(*collection);
 }
 
-void Node::invalidateNodeListAndCollectionCachesInAncestors(const QualifiedName* attrName, Element* attributeOwnerElement)
+void Node::invalidateNodeListAndCollectionCachesInAncestors()
 {
-    if (hasRareData() && (!attrName || isAttributeNode())) {
-        if (NodeListsNodeData* lists = rareData()->nodeLists())
+    if (hasRareData()) {
+        if (auto* lists = rareData()->nodeLists())
             lists->clearChildNodeListCache();
     }
 
-    // Modifications to attributes that are not associated with an Element can't invalidate NodeList caches.
-    if (attrName && !attributeOwnerElement)
+    if (!document().shouldInvalidateNodeListAndCollectionCaches())
         return;
 
-    if (!document().shouldInvalidateNodeListAndCollectionCaches(attrName))
+    document().invalidateNodeListAndCollectionCaches([](auto& list) {
+        list.invalidateCache();
+    });
+
+    for (auto* node = this; node; node = node->parentNode()) {
+        if (!node->hasRareData())
+            continue;
+
+        if (auto* lists = node->rareData()->nodeLists())
+            lists->invalidateCaches();
+    }
+}
+
+void Node::invalidateNodeListAndCollectionCachesInAncestorsForAttribute(const QualifiedName& attrName)
+{
+    ASSERT(is<Element>(*this));
+
+    if (!document().shouldInvalidateNodeListAndCollectionCachesForAttribute(attrName))
         return;
 
-    document().invalidateNodeListAndCollectionCaches(attrName);
+    document().invalidateNodeListAndCollectionCaches([&attrName](auto& list) {
+        list.invalidateCacheForAttribute(attrName);
+    });
 
-    for (Node* node = this; node; node = node->parentNode()) {
+    for (auto* node = this; node; node = node->parentNode()) {
         if (!node->hasRareData())
             continue;
-        NodeRareData* data = node->rareData();
-        if (data->nodeLists())
-            data->nodeLists()->invalidateCaches(attrName);
+
+        if (auto* lists = node->rareData()->nodeLists())
+            lists->invalidateCachesForAttribute(attrName);
     }
 }
 
@@ -1864,19 +1884,25 @@ void Node::showTreeForThisAcrossFrame() const
 
 // --------
 
-void NodeListsNodeData::invalidateCaches(const QualifiedName* attrName)
+void NodeListsNodeData::invalidateCaches()
 {
     for (auto& atomicName : m_atomicNameCaches)
-        atomicName.value->invalidateCacheForAttribute(attrName);
+        atomicName.value->invalidateCache();
 
     for (auto& collection : m_cachedCollections)
-        collection.value->invalidateCacheForAttribute(attrName);
-
-    if (attrName)
-        return;
+        collection.value->invalidateCache();
 
     for (auto& tagCollection : m_tagCollectionNSCache)
-        tagCollection.value->invalidateCacheForAttribute(nullptr);
+        tagCollection.value->invalidateCache();
+}
+
+void NodeListsNodeData::invalidateCachesForAttribute(const QualifiedName& attrName)
+{
+    for (auto& atomicName : m_atomicNameCaches)
+        atomicName.value->invalidateCacheForAttribute(attrName);
+
+    for (auto& collection : m_cachedCollections)
+        collection.value->invalidateCacheForAttribute(attrName);
 }
 
 void Node::getSubresourceURLs(ListHashSet<URL>& urls) const
index 2586a47..e8fffe6 100644 (file)
@@ -474,7 +474,8 @@ public:
     void showTreeForThisAcrossFrame() const;
 #endif // ENABLE(TREE_DEBUGGING)
 
-    void invalidateNodeListAndCollectionCachesInAncestors(const QualifiedName* attrName = nullptr, Element* attributeOwnerElement = nullptr);
+    void invalidateNodeListAndCollectionCachesInAncestors();
+    void invalidateNodeListAndCollectionCachesInAncestorsForAttribute(const QualifiedName& attrName);
     NodeListsNodeData* nodeLists();
     void clearNodeLists();
 
index 4153353..85d51cc 100644 (file)
@@ -195,7 +195,8 @@ public:
         m_cachedCollections.remove(namedCollectionKey(collection->type(), name));
     }
 
-    void invalidateCaches(const QualifiedName* attrName = nullptr);
+    void invalidateCaches();
+    void invalidateCachesForAttribute(const QualifiedName& attrName);
 
     void adoptTreeScope()
     {
@@ -210,15 +211,15 @@ public:
         }
 
         for (auto& cache : m_atomicNameCaches.values())
-            cache->invalidateCache(oldDocument);
+            cache->invalidateCacheForDocument(oldDocument);
 
         for (auto& list : m_tagCollectionNSCache.values()) {
             ASSERT(!list->isRootedAtDocument());
-            list->invalidateCache(oldDocument);
+            list->invalidateCacheForDocument(oldDocument);
         }
 
         for (auto& collection : m_cachedCollections.values())
-            collection->invalidateCache(oldDocument);
+            collection->invalidateCacheForDocument(oldDocument);
     }
 
 private:
index 3fb4752..00bb263 100644 (file)
@@ -53,7 +53,7 @@ public:
     bool collectionCanTraverseBackward() const { return traversalType != CollectionTraversalType::CustomForwardOnly; }
     void willValidateIndexCache() const { document().registerCollection(const_cast<CachedHTMLCollection<HTMLCollectionClass, traversalType>&>(*this)); }
 
-    void invalidateCache(Document&) override;
+    void invalidateCacheForDocument(Document&) override;
 
     bool elementMatches(Element&) const;
 
@@ -78,9 +78,9 @@ CachedHTMLCollection<HTMLCollectionClass, traversalType>::~CachedHTMLCollection(
 }
 
 template <typename HTMLCollectionClass, CollectionTraversalType traversalType>
-void CachedHTMLCollection<HTMLCollectionClass, traversalType>::invalidateCache(Document& document)
+void CachedHTMLCollection<HTMLCollectionClass, traversalType>::invalidateCacheForDocument(Document& document)
 {
-    HTMLCollection::invalidateCache(document);
+    HTMLCollection::invalidateCacheForDocument(document);
     if (m_indexCache.hasValidCache(collection())) {
         document.unregisterCollection(*this);
         m_indexCache.invalidate(collection());
index 8c1738a..efa53e3 100644 (file)
@@ -136,7 +136,7 @@ HTMLCollection::~HTMLCollection()
     }
 }
 
-void HTMLCollection::invalidateCache(Document& document)
+void HTMLCollection::invalidateCacheForDocument(Document& document)
 {
     if (hasNamedElementCache())
         invalidateNamedElementCache(document);
index 643a2e7..c1cb4cb 100644 (file)
@@ -79,8 +79,9 @@ public:
     CollectionType type() const;
     ContainerNode& ownerNode() const;
     ContainerNode& rootNode() const;
-    void invalidateCacheForAttribute(const QualifiedName* attributeName);
-    virtual void invalidateCache(Document&);
+    void invalidateCacheForAttribute(const QualifiedName& attributeName);
+    virtual void invalidateCacheForDocument(Document&);
+    void invalidateCache() { invalidateCacheForDocument(document()); }
 
     bool hasNamedElementCache() const;
 
@@ -195,11 +196,11 @@ inline Document& HTMLCollection::document() const
     return m_ownerNode->document();
 }
 
-inline void HTMLCollection::invalidateCacheForAttribute(const QualifiedName* attributeName)
+inline void HTMLCollection::invalidateCacheForAttribute(const QualifiedName& attributeName)
 {
-    if (!attributeName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attributeName))
-        invalidateCache(document());
-    else if (hasNamedElementCache() && (*attributeName == HTMLNames::idAttr || *attributeName == HTMLNames::nameAttr))
+    if (shouldInvalidateTypeOnAttributeChange(invalidationType(), attributeName))
+        invalidateCache();
+    else if (hasNamedElementCache() && (attributeName == HTMLNames::idAttr || attributeName == HTMLNames::nameAttr))
         invalidateNamedElementCache(document());
 }
 
index 2b54093..8b84c28 100644 (file)
@@ -141,9 +141,9 @@ void HTMLFormControlsCollection::updateNamedElementCache() const
     setNamedItemCache(WTFMove(cache));
 }
 
-void HTMLFormControlsCollection::invalidateCache(Document& document)
+void HTMLFormControlsCollection::invalidateCacheForDocument(Document& document)
 {
-    CachedHTMLCollection<HTMLFormControlsCollection, CollectionTypeTraits<FormControls>::traversalType>::invalidateCache(document);
+    CachedHTMLCollection<HTMLFormControlsCollection, CollectionTypeTraits<FormControls>::traversalType>::invalidateCacheForDocument(document);
     m_cachedElement = nullptr;
     m_cachedElementOffsetInArray = 0;
 }
index dc16635..c21f12d 100644 (file)
@@ -46,7 +46,7 @@ public:
 private:
     explicit HTMLFormControlsCollection(ContainerNode&);
 
-    void invalidateCache(Document&) override;
+    void invalidateCacheForDocument(Document&) override;
     void updateNamedElementCache() const override;
 
     const Vector<FormAssociatedElement*>& formControlElements() const;
index 84f5fca..f19756b 100644 (file)
@@ -741,7 +741,7 @@ const Vector<HTMLElement*>& HTMLSelectElement::listItems() const
 void HTMLSelectElement::invalidateSelectedItems()
 {
     if (HTMLCollection* collection = cachedHTMLCollection(SelectedOptions))
-        collection->invalidateCache(document());
+        collection->invalidateCache();
 }
 
 void HTMLSelectElement::setRecalcListItems()
@@ -753,7 +753,7 @@ void HTMLSelectElement::setRecalcListItems()
     invalidateStyleForSubtree();
     if (!isConnected()) {
         if (HTMLCollection* collection = cachedHTMLCollection(SelectOptions))
-            collection->invalidateCache(document());
+            collection->invalidateCache();
     }
     if (!isConnected())
         invalidateSelectedItems();
index 364c90e..8e88b5b 100644 (file)
@@ -1,3 +1,16 @@
+2017-05-10  Chris Dumez  <cdumez@apple.com>
+
+        Simplify relationship between Attr and Element now that Attr is childless
+        https://bugs.webkit.org/show_bug.cgi?id=171909
+
+        Reviewed by Ryosuke Niwa.
+
+        Build fix.
+
+        * DOM/DOMAttr.mm:
+        (-[DOMAttr value]):
+        (-[DOMAttr setValue:]):
+
 2017-05-08  Chris Dumez  <cdumez@apple.com>
 
         Move 'style' from Element to HTMLElement / SVGElement and make it settable
index 0774127..43923d7 100644 (file)
 - (NSString *)value
 {
     WebCore::JSMainThreadNullState state;
-    return IMPL->valueForBindings();
+    return IMPL->value();
 }
 
 - (void)setValue:(NSString *)newValue
 {
     WebCore::JSMainThreadNullState state;
-    IMPL->setValueForBindings(newValue);
+    IMPL->setValue(newValue);
 }
 
 - (DOMElement *)ownerElement
index 3bf8eba..02d9563 100644 (file)
@@ -257,7 +257,7 @@ gchar* webkit_dom_attr_get_value(WebKitDOMAttr* self)
     WebCore::JSMainThreadNullState state;
     g_return_val_if_fail(WEBKIT_DOM_IS_ATTR(self), 0);
     WebCore::Attr* item = WebKit::core(self);
-    gchar* result = convertToUTF8String(item->valueForBindings());
+    gchar* result = convertToUTF8String(item->value());
     return result;
 }
 
@@ -269,7 +269,7 @@ void webkit_dom_attr_set_value(WebKitDOMAttr* self, const gchar* value, GError**
     UNUSED_PARAM(error);
     WebCore::Attr* item = WebKit::core(self);
     WTF::String convertedValue = WTF::String::fromUTF8(value);
-    item->setValueForBindings(convertedValue);
+    item->setValue(convertedValue);
 }
 
 WebKitDOMElement* webkit_dom_attr_get_owner_element(WebKitDOMAttr* self)