ChangeLog

2011-12-13  Ryosuke Niwa  <rniwa@webkit.org>

        NodeChildList shouldn't be in NodeListNodeData

        https://bugs.webkit.org/show_bug.cgi?id=73969

        Reviewed by NOBODY (OOPS!).

        Move NodeChildList out of NodeListNodeData to separate it from the other node lists in order to

        resolve the bug 73853. Unlike other DynamicNodeList, we don't need to invalidate NodeChildList

        on ancestors when children change. Moving ChildNodeList out of NodeListNodeData makes this difference

        apparent and makes DynamicNodeList::Caches in NodeListNodeData always held by a DynamicSubtreeNodeList,

        eliminating the need for hasOwnCaches() checks in various places.

        Also renamed the existing DynamicNodeList to DynamicSubtreeNodeList and re-introduced DynamicNodeList

        from which DynamicSubtreeNodeList and ChildNodeList both inherit to share the code for itemWithName.

        In addition, renamed registerDynamicNodeList and unregisterDynamicNodeList, which updates a counter for

        TreeScope::hasNodeListCaches, to registerDynamicSubtreeNodeList and unregisterDynamicSubtreeNodeList

        respectively. They are no longer called by ChildNodeList in order to avoid walking up the DOM tree

        inside invalidateNodeListsCacheAfterAttributeChanged and invalidateNodeListsCacheAfterChildrenChanged.

        Test: fast/dom/childnode-item-after-itemname.html

        * bindings/js/JSNodeListCustom.cpp:

        (WebCore::JSNodeListOwner::isReachableFromOpaqueRoots):

        * dom/ChildNodeList.cpp:

        (WebCore::ChildNodeList::ChildNodeList):

        (WebCore::ChildNodeList::length):

        (WebCore::ChildNodeList::item):

        (WebCore::ChildNodeList::nodeMatches):

        * dom/ChildNodeList.h:

        * dom/ClassNodeList.cpp:

        (WebCore::ClassNodeList::ClassNodeList):

        (WebCore::ClassNodeList::~ClassNodeList):

        * dom/ClassNodeList.h:

        * dom/ContainerNode.cpp:

        (WebCore::ContainerNode::childrenChanged):

        * dom/DynamicNodeList.cpp:

        (WebCore::DynamicSubtreeNodeList::DynamicSubtreeNodeList):

        (WebCore::DynamicSubtreeNodeList::~DynamicSubtreeNodeList):

        (WebCore::DynamicSubtreeNodeList::length):

        (WebCore::DynamicSubtreeNodeList::itemForwardsFromCurrent):

        (WebCore::DynamicSubtreeNodeList::itemBackwardsFromCurrent):

        (WebCore::DynamicSubtreeNodeList::item):

        (WebCore::DynamicNodeList::itemWithName):

        (WebCore::DynamicSubtreeNodeList::isDynamicNodeList):

        (WebCore::DynamicSubtreeNodeList::invalidateCache):

        (WebCore::DynamicSubtreeNodeList::Caches::Caches):

        (WebCore::DynamicSubtreeNodeList::Caches::create):

        (WebCore::DynamicSubtreeNodeList::Caches::reset):

        * dom/DynamicNodeList.h:

        (WebCore::DynamicNodeList::DynamicNodeList):

        (WebCore::DynamicNodeList::~DynamicNodeList):

        (WebCore::DynamicNodeList::node):

        (WebCore::DynamicSubtreeNodeList::rootNode):

        * dom/NameNodeList.cpp:

        (WebCore::NameNodeList::NameNodeList):

        (WebCore::NameNodeList::~NameNodeList):

        * dom/NameNodeList.h:

        * dom/Node.cpp:

        (WebCore::Node::childNodes):

        (WebCore::Node::registerDynamicSubtreeNodeList):

        (WebCore::Node::unregisterDynamicSubtreeNodeList):

        (WebCore::Node::invalidateNodeListsCacheAfterAttributeChanged):

        (WebCore::Node::invalidateNodeListsCacheAfterChildrenChanged):

        (WebCore::Node::removeCachedClassNodeList):

        (WebCore::Node::removeCachedNameNodeList):

        (WebCore::Node::removeCachedTagNodeList):

        (WebCore::Node::removeCachedLabelsNodeList):

        (WebCore::NodeListsNodeData::invalidateCaches):

        (WebCore::NodeListsNodeData::isEmpty):

        (WebCore::NodeRareData::clearChildNodeListCache):

        * dom/Node.h:

        * dom/NodeRareData.h:

        (WebCore::NodeRareData::nodeLists):

        (WebCore::NodeRareData::ensureChildNodeListCache):

        * dom/TagNodeList.cpp:

        (WebCore::TagNodeList::TagNodeList):

        (WebCore::TagNodeList::~TagNodeList):

        * dom/TagNodeList.h:

        * html/LabelsNodeList.cpp:

        (WebCore::LabelsNodeList::LabelsNodeList):

        * html/LabelsNodeList.h:

2011-12-13  Robin Dunn  <robin@alldunn.com>

        Don't make the bitmap transparent when using theme drawing

102720

Source/WebCore/bindings/js/JSNodeListCustom.cpp

@@bool JSNodeListOwner::isReachableFromOpa

        return false;

    if (!jsNodeList->impl()->isDynamicNodeList())

        return false;

46 return visitor.containsOpaqueRoot(root(static_cast<DynamicNodeList*>(jsNodeList->impl())->~~rootN~~ode()));

46 return visitor.containsOpaqueRoot(root(static_cast<DynamicNodeList*>(jsNodeList->impl())->node()));

}

bool JSNodeList::canGetItemsForName(ExecState*, NodeList* impl, const Identifier& propertyName)

102444

Source/WebCore/dom/ChildNodeList.cpp

namespace WebCore {

30 ChildNodeList::ChildNodeList(PassRefPtr<Node> rootNode, DynamicNodeList::Caches* info)

31 : DynamicNodeList(rootNode, info)

ChildNodeList::ChildNodeList(PassRefPtr<Node> node, DynamicNodeList::Caches* caches)

    : DynamicNodeList(node)

    , m_caches(caches)

{

}

@@unsigned ChildNodeList::length() const

        return m_caches->cachedLength;

    unsigned len = 0;

41 for (Node* n = ~~m_rootN~~ode->firstChild(); n; n = n->nextSibling())

42 for (Node* n = node()->firstChild(); n; n = n->nextSibling())

        len++;

    m_caches->cachedLength = len;

@@unsigned ChildNodeList::length() const

Node* ChildNodeList::item(unsigned index) const

{

    unsigned int pos = 0;

53 Node* n = ~~m_rootN~~ode->firstChild();

54 Node* n = node()->firstChild();

    if (m_caches->isItemCacheValid) {

        if (index == m_caches->lastItemOffset)

@@Node* ChildNodeList::item(unsigned index

        int diff = index - pos;

        unsigned dist = abs(diff);

        if (dist > m_caches->cachedLength - 1 - index) {

74 n = ~~m_rootN~~ode->lastChild();

75 n = node()->lastChild();

            pos = m_caches->cachedLength - 1;

        }

    }

@@bool ChildNodeList::nodeMatches(Element*

    // Note: Due to the overrides of the length and item functions above,

    // this function will be called only by DynamicNodeList::itemWithName,

    // for an element that was located with getElementById.

106 return testNode->parentNode() == ~~m_rootN~~ode;

107 return testNode->parentNode() == node();

}

} // namespace WebCore

102444

Source/WebCore/dom/ChildNodeList.h

@@namespace WebCore {

        ChildNodeList(PassRefPtr<Node> rootNode, Caches*);

        virtual bool nodeMatches(Element*) const;

46

47 mutable RefPtr<DynamicNodeList::Caches> m_caches;

    };

} // namespace WebCore

102444

Source/WebCore/dom/ClassNodeList.cpp

namespace WebCore {

ClassNodeList::ClassNodeList(PassRefPtr<Node> rootNode, const String& classNames)

39 : DynamicNodeList(rootNode)

40 , m_classNames(classNames, ~~m_rootN~~ode->document()->inQuirksMode())

39 : DynamicSubtreeNodeList(rootNode)

40 , m_classNames(classNames, node()->document()->inQuirksMode())

    , m_originalClassNames(classNames)

{

}

ClassNodeList::~ClassNodeList()

{

47 m_rootNode->removeCachedClassNodeList(this, m_originalClassNames);

47 rootNode()->removeCachedClassNodeList(this, m_originalClassNames);

} 

bool ClassNodeList::nodeMatches(Element* testNode) const

102444

Source/WebCore/dom/ClassNodeList.h

namespace WebCore {

39 class ClassNodeList : public DynamicNodeList {

39 class ClassNodeList : public DynamicSubtreeNodeList {

    public:

        static PassRefPtr<ClassNodeList> create(PassRefPtr<Node> rootNode, const String& classNames)

        {

102444

Source/WebCore/dom/ContainerNode.cpp

@@void ContainerNode::childrenChanged(bool

    Node::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);

    if (!changedByParser && childCountDelta)

        document()->updateRangesAfterChildrenChanged(this);

847 if (treeScope()->hasNodeListCaches())

848 invalidateNodeListsCacheAfterChildrenChanged();

847 invalidateNodeListsCacheAfterChildrenChanged();

}

void ContainerNode::cloneChildNodes(ContainerNode *clone)

102444

Source/WebCore/dom/DynamicNodeList.cpp

namespace WebCore {

31 DynamicNodeList::DynamicNodeList(PassRefPtr<Node> ~~rootN~~ode)

32 : ~~m_root~~Node~~(rootN~~ode)

31DynamicSubtreeNodeList::DynamicSubtreeNodeList(PassRefPtr<Node> node)

32 : DynamicNodeList(node)

3333 , m_caches(Caches::create())

34 , m_ownsCaches(true)

3534{

    m_rootNode->registerDynamicNodeList(this);

}    

DynamicNodeList::DynamicNodeList(PassRefPtr<Node> rootNode, DynamicNodeList::Caches* caches)

    : m_rootNode(rootNode)

    , m_caches(caches)

    , m_ownsCaches(false)

{

    m_rootNode->registerDynamicNodeList(this);

}

35 rootNode()->registerDynamicSubtreeNodeList(this);

36}

4637

47 DynamicNodeList::~DynamicNodeList()

38DynamicSubtreeNodeList::~DynamicSubtreeNodeList()

4839{

49 m_rootNode->unregisterDynamicNodeList(this);

40 rootNode()->unregisterDynamicSubtreeNodeList(this);

5041}

5142

52 unsigned DynamicNodeList::length() const

43unsigned DynamicSubtreeNodeList::length() const

{

    if (m_caches->isLengthCacheValid)

        return m_caches->cachedLength;

    unsigned length = 0;

59 for (Node* n = ~~m_rootN~~ode->firstChild(); n; n = n->traverseNextNode(m_rootNode~~.get~~()))

50 for (Node* n = node()->firstChild(); n; n = n->traverseNextNode(rootNode()))

        length += n->isElementNode() && nodeMatches(static_cast<Element*>(n));

    m_caches->cachedLength = length;

@@unsigned DynamicNodeList::length() const

    return length;

}

68 Node* DynamicNodeList::itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const

59Node* DynamicSubtreeNodeList::itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const

6960{

7061 ASSERT(remainingOffset >= 0);

71 for (Node* n = start; n; n = n->traverseNextNode(m_rootNode~~.get~~())) {

62 for (Node* n = start; n; n = n->traverseNextNode(rootNode())) {

        if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) {

            if (!remainingOffset) {

                m_caches->lastItem = n;

@@Node* DynamicNodeList::itemForwardsFromC

    return 0; // no matching node in this subtree

}

86 Node* DynamicNodeList::itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const

77Node* DynamicSubtreeNodeList::itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const

8778{

8879 ASSERT(remainingOffset < 0);

89 for (Node* n = start; n; n = n->traversePreviousNode(m_rootNode~~.get~~())) {

80 for (Node* n = start; n; n = n->traversePreviousNode(rootNode())) {

        if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) {

            if (!remainingOffset) {

                m_caches->lastItem = n;

@@Node* DynamicNodeList::itemBackwardsFrom

    return 0; // no matching node in this subtree

}

104 Node* DynamicNodeList::item(unsigned offset) const

95Node* DynamicSubtreeNodeList::item(unsigned offset) const

10596{

10697 int remainingOffset = offset;

107 Node* start = ~~m_rootN~~ode->firstChild();

98 Node* start = node()->firstChild();

    if (m_caches->isItemCacheValid) {

        if (offset == m_caches->lastItemOffset)

            return m_caches->lastItem;

@@Node* DynamicNodeList::item(unsigned off

Node* DynamicNodeList::itemWithName(const AtomicString& elementId) const

{

    if (m_rootNode->isDocumentNode() || m_rootNode->inDocument()) {

        Element* node = m_rootNode->treeScope()->getElementById(elementId);

        if (node && nodeMatches(node)) {

            for (ContainerNode* p = node->parentNode(); p; p = p->parentNode()) {

                if (p == m_rootNode)

                    return node;

            }

        }

    if (node()->isDocumentNode() || node()->inDocument()) {

        Element* node = this->node()->treeScope()->getElementById(elementId);

        if (node && nodeMatches(node) && node->isDescendantOf(this->node()))

            return node;

        if (!node)

            return 0;

        // In the case of multiple nodes with the same name, just fall through.

@@Node* DynamicNodeList::itemWithName(cons

    return 0;

}

148 bool DynamicNodeList::isDynamicNodeList() const

135bool DynamicSubtreeNodeList::isDynamicNodeList() const

{

    return true;

}

153 void DynamicNodeList::invalidateCache()

140void DynamicSubtreeNodeList::invalidateCache()

154141{

155 // This should only be called for node lists that own their own caches.

156 ASSERT(m_ownsCaches);

    m_caches->reset();

}

160 DynamicNodeList::Caches::Caches()

145DynamicSubtreeNodeList::Caches::Caches()

    : lastItem(0)

    , isLengthCacheValid(false)

    , isItemCacheValid(false)

{

}

167 PassRefPtr<DynamicNodeList::Caches> DynamicNodeList::Caches::create()

152PassRefPtr<DynamicSubtreeNodeList::Caches> DynamicSubtreeNodeList::Caches::create()

{

    return adoptRef(new Caches());

}

172 void DynamicNodeList::Caches::reset()

157void DynamicSubtreeNodeList::Caches::reset()

{

    lastItem = 0;

    isLengthCacheValid = false;

102444

Source/WebCore/dom/DynamicNodeList.h

namespace WebCore {

    class Element;

    class Node;

    class DynamicNodeList : public NodeList {

    public:

        struct Caches : RefCounted<Caches> {

            static PassRefPtr<Caches> create();

            void reset();

            unsigned cachedLength;

            Node* lastItem;

            unsigned lastItemOffset;

            bool isLengthCacheValid : 1;

            bool isItemCacheValid : 1;

        protected:

            Caches();

        };

        virtual ~DynamicNodeList();

        bool hasOwnCaches() const { return m_ownsCaches; }

        // DOM methods & attributes for NodeList

        virtual unsigned length() const;

        virtual Node* item(unsigned index) const;

        virtual Node* itemWithName(const AtomicString&) const;

        // Other methods (not part of DOM)

        void invalidateCache();

        Node* rootNode() const { return m_rootNode.get(); }

34class Element;

35class Node;

6436

class DynamicNodeList : public NodeList {

public:

    struct Caches : RefCounted<Caches> {

        static PassRefPtr<Caches> create();

        void reset();

        unsigned cachedLength;

        Node* lastItem;

        unsigned lastItemOffset;

        bool isLengthCacheValid : 1;

        bool isItemCacheValid : 1;

6548 protected:

        DynamicNodeList(PassRefPtr<Node> rootNode);

        DynamicNodeList(PassRefPtr<Node> rootNode, Caches*);

        virtual bool nodeMatches(Element*) const = 0;

        RefPtr<Node> m_rootNode;

        mutable RefPtr<Caches> m_caches;

        bool m_ownsCaches;

    private:

        virtual bool isDynamicNodeList() const;

        Node* itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const;

        Node* itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const;

49 Caches();

7950 };

    DynamicNodeList(PassRefPtr<Node> node)

        : m_node(node)

    { }

    virtual ~DynamicNodeList() { }

    // DOM methods & attributes for NodeList

    virtual unsigned length() const = 0;

    virtual Node* item(unsigned index) const = 0;

    virtual Node* itemWithName(const AtomicString&) const;

    // Other methods (not part of DOM)

    Node* node() const { return m_node.get(); }

protected:

    virtual bool nodeMatches(Element*) const = 0;

    RefPtr<Node> m_node;

};

class DynamicSubtreeNodeList : public DynamicNodeList {

public:

    virtual ~DynamicSubtreeNodeList();

    virtual unsigned length() const OVERRIDE;

    virtual Node* item(unsigned index) const OVERRIDE;

    void invalidateCache();

    Node* rootNode() const { return node(); }

protected:

    DynamicSubtreeNodeList(PassRefPtr<Node> rootNode);

    mutable RefPtr<Caches> m_caches;

private:

    virtual bool isDynamicNodeList() const;

    Node* itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const;

    Node* itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const;

};

} // namespace WebCore

102444

Source/WebCore/dom/NameNodeList.cpp

@@namespace WebCore {

using namespace HTMLNames;

NameNodeList::NameNodeList(PassRefPtr<Node> rootNode, const String& name)

35 : DynamicNodeList(rootNode)

35 : DynamicSubtreeNodeList(rootNode)

    , m_nodeName(name)

{

}

NameNodeList::~NameNodeList()

{

42 m_rootNode->removeCachedNameNodeList(this, m_nodeName);

42 rootNode()->removeCachedNameNodeList(this, m_nodeName);

} 

bool NameNodeList::nodeMatches(Element* testNode) const

102444

Source/WebCore/dom/NameNodeList.h

namespace WebCore {

    // NodeList which lists all Nodes in a Element with a given "name" attribute

34 class NameNodeList : public DynamicNodeList {

34 class NameNodeList : public DynamicSubtreeNodeList {

    public:

        static PassRefPtr<NameNodeList> create(PassRefPtr<Node> rootNode, const String& name)

        {

102444

Source/WebCore/dom/Node.cpp

@@void Node::setNodeValue(const String& /*

PassRefPtr<NodeList> Node::childNodes()

{

    NodeListsNodeData* nodeLists = ensureRareData()->ensureNodeLists(this);

    if (!nodeLists->m_childNodeListCaches)

        nodeLists->m_childNodeListCaches = DynamicNodeList::Caches::create();

    return ChildNodeList::create(this, nodeLists->m_childNodeListCaches.get());

626 return ChildNodeList::create(this, ensureRareData()->ensureChildNodeListCache());

}

Node *Node::lastDescendant() const

@@static void removeNodeListCacheIfPossibl

    node->treeScope()->removeNodeListCache();

}

1007 void Node::registerDynamicNodeList(DynamicNodeList* list)

1004void Node::registerDynamicSubtreeNodeList(DynamicSubtreeNodeList* list)

{

    NodeRareData* data = ensureRareData();

    // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.

    if (data->nodeLists() && (!treeScope() || !treeScope()->hasNodeListCaches()))

        data->nodeLists()->invalidateCaches();

1014 if (list->hasOwnCaches())

1015 data->ensureNodeLists(this)->m_listsWithCaches.add(list);

1011 data->ensureNodeLists(this)->m_listsWithCaches.add(list);

10161012}

10171013

1018 void Node::unregisterDynamicNodeList(DynamicNodeList* list)

1014void Node::unregisterDynamicSubtreeNodeList(DynamicSubtreeNodeList* list)

10191015{

1020 ASSERT(rareData());

1016 ASSERT(hasRareData());

10211017 ASSERT(rareData()->nodeLists());

    if (list->hasOwnCaches()) {

        NodeRareData* data = rareData();

        data->nodeLists()->m_listsWithCaches.remove(list);

        removeNodeListCacheIfPossible(this, data);

    }

    NodeRareData* data = rareData();

    data->nodeLists()->m_listsWithCaches.remove(list);

    removeNodeListCacheIfPossible(this, data);

}

void Node::invalidateNodeListsCacheAfterAttributeChanged()

{

    if (hasRareData() && isAttributeNode()) {

        NodeRareData* data = rareData();

        ASSERT(!data->nodeLists());

        data->clearChildNodeListCache();

    }

    if (!treeScope()->hasNodeListCaches())

        return;

10311034 for (Node* node = this; node; node = node->parentNode()) {

1035 ASSERT(this == node || !node->isAttributeNode());

        if (!node->hasRareData())

            continue;

        NodeRareData* data = node->rareData();

        if (!data->nodeLists())

            continue;

        // For attribute nodes, we need to invalidate childNodes as well.

        if (node->isAttributeNode())

            data->nodeLists()->invalidateCaches();

        else

            data->nodeLists()->invalidateCachesThatDependOnAttributes();

1042 data->nodeLists()->invalidateCachesThatDependOnAttributes();

        removeNodeListCacheIfPossible(node, data);

    }

}

void Node::invalidateNodeListsCacheAfterChildrenChanged()

{

    if (hasRareData())

        rareData()->clearChildNodeListCache();

    if (!treeScope()->hasNodeListCaches())

        return;

    for (Node* node = this; node; node = node->parentNode()) {

        if (!node->hasRareData())

            continue;

@@void Node::removeCachedClassNodeList(Cla

{

    ASSERT(rareData());

    ASSERT(rareData()->nodeLists());

1083 ASSERT_UNUSED(list, list->hasOwnCaches());

    NodeListsNodeData* data = rareData()->nodeLists();

    ASSERT_UNUSED(list, list == data->m_classNodeListCache.get(className));

@@void Node::removeCachedNameNodeList(Name

{

    ASSERT(rareData());

    ASSERT(rareData()->nodeLists());

1094 ASSERT_UNUSED(list, list->hasOwnCaches());

    NodeListsNodeData* data = rareData()->nodeLists();

    ASSERT_UNUSED(list, list == data->m_nameNodeListCache.get(nodeName));

@@void Node::removeCachedTagNodeList(TagNo

{

    ASSERT(rareData());

    ASSERT(rareData()->nodeLists());

1105 ASSERT_UNUSED(list, list->hasOwnCaches());

    NodeListsNodeData* data = rareData()->nodeLists();

    ASSERT_UNUSED(list, list == data->m_tagNodeListCache.get(name.impl()));

@@void Node::removeCachedTagNodeList(TagNo

{

    ASSERT(rareData());

    ASSERT(rareData()->nodeLists());

1116 ASSERT_UNUSED(list, list->hasOwnCaches());

    NodeListsNodeData* data = rareData()->nodeLists();

    ASSERT_UNUSED(list, list == data->m_tagNodeListCacheNS.get(name.impl()));

    data->m_tagNodeListCacheNS.remove(name.impl());

}

1123 void Node::removeCachedLabelsNodeList(DynamicNodeList* list)

1123void Node::removeCachedLabelsNodeList(DynamicSubtreeNodeList* list)

{

    ASSERT(rareData());

    ASSERT(rareData()->nodeLists());

1127 ASSERT_UNUSED(list, list->hasOwnCaches());

1128

1127

11291128 NodeListsNodeData* data = rareData()->nodeLists();

1129 ASSERT_UNUSED(list, list == data->m_labelsNodeListCache);

    data->m_labelsNodeListCache = 0;

}

@@void Node::showTreeForThisAcrossFrame()

void NodeListsNodeData::invalidateCaches()

{

    if (m_childNodeListCaches) {

        if (m_childNodeListCaches->hasOneRef())

            m_childNodeListCaches.clear();

        else

            m_childNodeListCaches->reset();

    }

    if (m_labelsNodeListCache)

        m_labelsNodeListCache->invalidateCache();

    TagNodeListCache::const_iterator tagCacheEnd = m_tagNodeListCache.end();

@@bool NodeListsNodeData::isEmpty() const

    if (!m_listsWithCaches.isEmpty())

        return false;

    if (m_childNodeListCaches)

        return false;

    if (!m_tagNodeListCache.isEmpty())

        return false;

    if (!m_tagNodeListCacheNS.isEmpty())

@@void NodeRareData::createNodeLists(Node*

        treeScope->addNodeListCache();

}

void NodeRareData::clearChildNodeListCache()

{

    if (!m_childNodeListCache)

        return;

    if (m_childNodeListCache->hasOneRef())

        m_childNodeListCache.clear();

    else

        m_childNodeListCache->reset();

}

} // namespace WebCore

#ifndef NDEBUG

102444

Source/WebCore/dom/Node.h

@@class ClassNodeList;

class ContainerNode;

class DOMSettableTokenList;

class Document;

53 class DynamicNodeList;

53class DynamicSubtreeNodeList;

class Element;

class Event;

class EventContext;

@@public:

    void showTreeForThisAcrossFrame() const;

#endif

520 void registerDynamicNodeList(DynamicNodeList*);

521 void unregisterDynamicNodeList(DynamicNodeList*);

520 void registerDynamicSubtreeNodeList(DynamicSubtreeNodeList*);

521 void unregisterDynamicSubtreeNodeList(DynamicSubtreeNodeList*);

    void invalidateNodeListsCacheAfterAttributeChanged();

    void invalidateNodeListsCacheAfterChildrenChanged();

    void notifyLocalNodeListsLabelChanged();

@@public:

    void removeCachedNameNodeList(NameNodeList*, const String&);

    void removeCachedTagNodeList(TagNodeList*, const AtomicString&);

    void removeCachedTagNodeList(TagNodeList*, const QualifiedName&);

530 void removeCachedLabelsNodeList(DynamicNodeList*);

530 void removeCachedLabelsNodeList(DynamicSubtreeNodeList*);

    PassRefPtr<NodeList> getElementsByTagName(const AtomicString&);

    PassRefPtr<NodeList> getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName);

102444

Source/WebCore/dom/NodeRareData.h

#ifndef NodeRareData_h

#define NodeRareData_h

25#include "ChildNodeList.h"

#include "ClassNodeList.h"

#include "DOMSettableTokenList.h"

#include "DynamicNodeList.h"

@@class TreeScope;

struct NodeListsNodeData {

    WTF_MAKE_NONCOPYABLE(NodeListsNodeData); WTF_MAKE_FAST_ALLOCATED;

public:

52 typedef HashSet<DynamicNodeList*> NodeListSet;

53 typedef HashSet<DynamicSubtreeNodeList*> NodeListSet;

5354 NodeListSet m_listsWithCaches;

    
    RefPtr<DynamicNodeList::Caches> m_childNodeListCaches;

55

    typedef HashMap<String, ClassNodeList*> ClassNodeListCache;

    ClassNodeListCache m_classNodeListCache;

@@public:

    void clearNodeLists() { m_nodeLists.clear(); }

    void setNodeLists(PassOwnPtr<NodeListsNodeData> lists) { m_nodeLists = lists; }

    NodeListsNodeData* nodeLists() const { return m_nodeLists.get(); }

129

    NodeListsNodeData* ensureNodeLists(Node* node)

    {

        if (!m_nodeLists)

            createNodeLists(node);

        return m_nodeLists.get();

    }

    void clearChildNodeListCache();

    DynamicNodeList::Caches* ensureChildNodeListCache()

    {

        if (!m_childNodeListCache)

            m_childNodeListCache = DynamicNodeList::Caches::create();

        return m_childNodeListCache.get();

    }

    short tabIndex() const { return m_tabIndex; }

    void setTabIndexExplicitly(short index) { m_tabIndex = index; m_tabIndexWasSetExplicitly = true; }

@@private:

    TreeScope* m_treeScope;

    OwnPtr<NodeListsNodeData> m_nodeLists;

244 RefPtr<DynamicNodeList::Caches> m_childNodeListCache;

    OwnPtr<EventTargetData> m_eventTargetData;

    short m_tabIndex;

    bool m_tabIndexWasSetExplicitly : 1;

102444

Source/WebCore/dom/TagNodeList.cpp

namespace WebCore {

TagNodeList::TagNodeList(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName)

33 : DynamicNodeList(rootNode)

33 : DynamicSubtreeNodeList(rootNode)

    , m_namespaceURI(namespaceURI)

    , m_localName(localName)

{

@@TagNodeList::TagNodeList(PassRefPtr<Node

TagNodeList::~TagNodeList()

{

    if (m_namespaceURI == starAtom)

43 m_rootNode->removeCachedTagNodeList(this, m_localName);

43 rootNode()->removeCachedTagNodeList(this, m_localName);

4444 else

45 m_rootNode->removeCachedTagNodeList(this, QualifiedName(nullAtom, m_localName, m_namespaceURI));

45 rootNode()->removeCachedTagNodeList(this, QualifiedName(nullAtom, m_localName, m_namespaceURI));

}

bool TagNodeList::nodeMatches(Element* testNode) const

102444

Source/WebCore/dom/TagNodeList.h

namespace WebCore {

    // NodeList that limits to a particular tag.

33 class TagNodeList : public DynamicNodeList {

33 class TagNodeList : public DynamicSubtreeNodeList {

    public:

        static PassRefPtr<TagNodeList> create(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName)

        {

102444

Source/WebCore/html/LabelsNodeList.cpp

@@namespace WebCore {

using namespace HTMLNames;

LabelsNodeList::LabelsNodeList(Node* forNode )

36 : DynamicNodeList(forNode->document()) , m_forNode(forNode)

36 : DynamicSubtreeNodeList(forNode->document()) , m_forNode(forNode)

{

}

102444

Source/WebCore/html/LabelsNodeList.h

namespace WebCore {

33 class LabelsNodeList : public DynamicNodeList {

33class LabelsNodeList : public DynamicSubtreeNodeList {

public:

    static PassRefPtr<LabelsNodeList> create(Node* forNode)

    {

102444

LayoutTests/ChangeLog

2011-12-09  Ryosuke Niwa  <rniwa@webkit.org>

        NodeChildList shouldn't be in NodeListNodeData

        https://bugs.webkit.org/show_bug.cgi?id=73969

        Added a regression test for ChildNodeList; it catches a bug caught in the review process.

        * fast/dom/childnode-item-after-itemname-expected.txt: Added.

        * fast/dom/childnode-item-after-itemname.html: Added.

2011-12-09  Tony Chang  <tony@chromium.org>

        Fix test expectations from r102486: flex-flow returns direction and wrap now.

102496

LayoutTests/fast/dom/childnode-item-after-itemname-expected.txt

This tests accessing the first element in childNodes after accessing the second element by its id. WebKit should retrieve each element correctly, and you should see 2 1 below:

2 1

0

LayoutTests/fast/dom/childnode-item-after-itemname.html

<!DOCTYPE html>

<html>

<body>

<p>This tests accessing the first element in childNodes after accessing the second element by its id.

WebKit should retrieve each element correctly, and you should see 2 1 below:</p>

<span id="item"></span><span id="tests" style="display: none;">1<span id="item">2</span></span>

<script>

if (window.layoutTestController)

    layoutTestController.dumpAsText();

var tests = document.querySelector('#tests');

document.writeln(tests.childNodes['item'].textContent);

document.writeln(tests.childNodes[0].textContent);

</script>

</body>

</html>

0