CTTE: Live node lists always have an owner Node.
authorakling@apple.com <akling@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 7 Oct 2013 23:05:58 +0000 (23:05 +0000)
committerakling@apple.com <akling@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 7 Oct 2013 23:05:58 +0000 (23:05 +0000)
<https://webkit.org/b/122470>

Reviewed by Anders Carlsson.

Make LiveNodeListBase::m_ownerNode a Ref<Node> instead of a RefPtr
and have all constructors take Node&.

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

35 files changed:
Source/WebCore/ChangeLog
Source/WebCore/bindings/js/JSHTMLFormControlsCollectionCustom.cpp
Source/WebCore/bindings/js/JSHTMLOptionsCollectionCustom.cpp
Source/WebCore/bindings/js/JSNodeCustom.h
Source/WebCore/dom/ChildNodeList.cpp
Source/WebCore/dom/ChildNodeList.h
Source/WebCore/dom/ClassNodeList.cpp
Source/WebCore/dom/ClassNodeList.h
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/LiveNodeList.cpp
Source/WebCore/dom/LiveNodeList.h
Source/WebCore/dom/NameNodeList.cpp
Source/WebCore/dom/NameNodeList.h
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/NodeRareData.h
Source/WebCore/dom/TagNodeList.cpp
Source/WebCore/dom/TagNodeList.h
Source/WebCore/html/HTMLAllCollection.cpp
Source/WebCore/html/HTMLAllCollection.h
Source/WebCore/html/HTMLCollection.cpp
Source/WebCore/html/HTMLCollection.h
Source/WebCore/html/HTMLFormControlsCollection.cpp
Source/WebCore/html/HTMLFormControlsCollection.h
Source/WebCore/html/HTMLNameCollection.cpp
Source/WebCore/html/HTMLNameCollection.h
Source/WebCore/html/HTMLOptionsCollection.cpp
Source/WebCore/html/HTMLOptionsCollection.h
Source/WebCore/html/HTMLTableRowsCollection.cpp
Source/WebCore/html/HTMLTableRowsCollection.h
Source/WebCore/html/LabelableElement.cpp
Source/WebCore/html/LabelsNodeList.cpp
Source/WebCore/html/LabelsNodeList.h
Source/WebCore/html/RadioNodeList.cpp
Source/WebCore/html/RadioNodeList.h

index d57fd6e79ba8c85ac40a9ea9bd4645550139dd8e..0e1aef399b62d9f9cbaabede26a973af6c68b7f3 100644 (file)
@@ -1,3 +1,13 @@
+2013-10-07  Andreas Kling  <akling@apple.com>
+
+        CTTE: Live node lists always have an owner Node.
+        <https://webkit.org/b/122470>
+
+        Reviewed by Anders Carlsson.
+
+        Make LiveNodeListBase::m_ownerNode a Ref<Node> instead of a RefPtr
+        and have all constructors take Node&.
+
 2013-10-07  Anders Carlsson  <andersca@apple.com>
 
         Clean up ScriptExecutionContext::Task and subclasses
 2013-10-07  Anders Carlsson  <andersca@apple.com>
 
         Clean up ScriptExecutionContext::Task and subclasses
index 00ddd75e20ff3fa64f18de6f19a6eedd49b0b134..0dd97201b64713d6fb98a8094cf6fda7a4552b20 100644 (file)
@@ -49,7 +49,7 @@ static JSValue getNamedItems(ExecState* exec, JSHTMLFormControlsCollection* coll
         return toJS(exec, collection->globalObject(), &namedItems[0].get());
 
     ASSERT(collection->impl()->type() == FormControls);
         return toJS(exec, collection->globalObject(), &namedItems[0].get());
 
     ASSERT(collection->impl()->type() == FormControls);
-    return toJS(exec, collection->globalObject(), collection->impl()->ownerNode()->radioNodeList(name).get());
+    return toJS(exec, collection->globalObject(), collection->impl()->ownerNode().radioNodeList(name).get());
 }
 
 bool JSHTMLFormControlsCollection::canGetItemsForName(ExecState*, HTMLFormControlsCollection* collection, PropertyName propertyName)
 }
 
 bool JSHTMLFormControlsCollection::canGetItemsForName(ExecState*, HTMLFormControlsCollection* collection, PropertyName propertyName)
index 54a907d44bd66dfe1843678893bdc49be67bd36f..1c3fb905df967e2584ac1eee12c9aa293ba5186a 100644 (file)
@@ -59,8 +59,8 @@ void JSHTMLOptionsCollection::setLength(ExecState* exec, JSValue value)
 void JSHTMLOptionsCollection::indexSetter(ExecState* exec, unsigned index, JSValue value)
 {
     HTMLOptionsCollection* imp = impl();
 void JSHTMLOptionsCollection::indexSetter(ExecState* exec, unsigned index, JSValue value)
 {
     HTMLOptionsCollection* imp = impl();
-    HTMLSelectElement* base = toHTMLSelectElement(imp->ownerNode());
-    selectIndexSetter(base, exec, index, value);
+    HTMLSelectElement& base = toHTMLSelectElement(imp->ownerNode());
+    selectIndexSetter(&base, exec, index, value);
 }
 
 JSValue JSHTMLOptionsCollection::add(ExecState* exec)
 }
 
 JSValue JSHTMLOptionsCollection::add(ExecState* exec)
index f812f6f597cd82e2493994ee333a856cad4e2cef..2880274ed63624d1075d8f1b81ddf3aa779f6f33 100644 (file)
@@ -73,6 +73,11 @@ inline void* root(Node* node)
     return node;
 }
 
     return node;
 }
 
+inline void* root(Node& node)
+{
+    return root(&node);
+}
+
 } // namespace WebCore
 
 #endif // JSDOMNodeCustom_h
 } // namespace WebCore
 
 #endif // JSDOMNodeCustom_h
index 26cae9499341a09805c8add2f85c5445aeafffab..5ecdd87c885ed5b6ab21ea3c671f25df7568e831 100644 (file)
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-ChildNodeList::ChildNodeList(PassRefPtr<Node> node)
+ChildNodeList::ChildNodeList(Node& node)
     : LiveNodeList(node, ChildNodeListType, DoNotInvalidateOnAttributeChanges)
 {
 }
 
 ChildNodeList::~ChildNodeList()
 {
     : LiveNodeList(node, ChildNodeListType, DoNotInvalidateOnAttributeChanges)
 {
 }
 
 ChildNodeList::~ChildNodeList()
 {
-    ownerNode()->nodeLists()->removeChildNodeList(this);
+    ownerNode().nodeLists()->removeChildNodeList(this);
 }
 
 bool ChildNodeList::nodeMatches(Element* testNode) const
 }
 
 bool ChildNodeList::nodeMatches(Element* testNode) const
index 456e52c2a42d08e77ba5a71a96ccf7d1fcca138a..e78b72323a24cc3e358e828a236b9bfc7c80efad 100644 (file)
@@ -31,7 +31,7 @@ namespace WebCore {
 
     class ChildNodeList : public LiveNodeList {
     public:
 
     class ChildNodeList : public LiveNodeList {
     public:
-        static PassRefPtr<ChildNodeList> create(PassRefPtr<Node> rootNode)
+        static PassRefPtr<ChildNodeList> create(Node& rootNode)
         {
             return adoptRef(new ChildNodeList(rootNode));
         }
         {
             return adoptRef(new ChildNodeList(rootNode));
         }
@@ -39,7 +39,7 @@ namespace WebCore {
         virtual ~ChildNodeList();
 
     protected:
         virtual ~ChildNodeList();
 
     protected:
-        explicit ChildNodeList(PassRefPtr<Node> rootNode);
+        explicit ChildNodeList(Node& rootNode);
 
         virtual bool nodeMatches(Element*) const OVERRIDE;
     };
 
         virtual bool nodeMatches(Element*) const OVERRIDE;
     };
index 9f081cacfaf8792860b1a1a31de50b99d71f8161..fdcdd84ca1b31d89ddaf28190c3ea978f9edf531 100644 (file)
@@ -36,7 +36,7 @@
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-ClassNodeList::ClassNodeList(PassRefPtr<Node> rootNode, const String& classNames)
+ClassNodeList::ClassNodeList(Node& rootNode, const String& classNames)
     : LiveNodeList(rootNode, ClassNodeListType, InvalidateOnClassAttrChange)
     , m_classNames(classNames, document()->inQuirksMode())
     , m_originalClassNames(classNames)
     : LiveNodeList(rootNode, ClassNodeListType, InvalidateOnClassAttrChange)
     , m_classNames(classNames, document()->inQuirksMode())
     , m_originalClassNames(classNames)
@@ -45,7 +45,7 @@ ClassNodeList::ClassNodeList(PassRefPtr<Node> rootNode, const String& classNames
 
 ClassNodeList::~ClassNodeList()
 {
 
 ClassNodeList::~ClassNodeList()
 {
-    ownerNode()->nodeLists()->removeCacheWithName(this, ClassNodeListType, m_originalClassNames);
+    ownerNode().nodeLists()->removeCacheWithName(this, ClassNodeListType, m_originalClassNames);
 } 
 
 bool ClassNodeList::nodeMatches(Element* testNode) const
 } 
 
 bool ClassNodeList::nodeMatches(Element* testNode) const
index 05e508b04995df0f316d200cc9288474570c7822..87764eb710947307243dc25d10062c6f150997a9 100644 (file)
@@ -39,7 +39,7 @@ namespace WebCore {
 
 class ClassNodeList : public LiveNodeList {
 public:
 
 class ClassNodeList : public LiveNodeList {
 public:
-    static PassRefPtr<ClassNodeList> create(PassRefPtr<Node> rootNode, const String& classNames)
+    static PassRefPtr<ClassNodeList> create(Node& rootNode, const String& classNames)
     {
         return adoptRef(new ClassNodeList(rootNode, classNames));
     }
     {
         return adoptRef(new ClassNodeList(rootNode, classNames));
     }
@@ -49,7 +49,7 @@ public:
     bool nodeMatchesInlined(Element*) const;
 
 private:
     bool nodeMatchesInlined(Element*) const;
 
 private:
-    ClassNodeList(PassRefPtr<Node> rootNode, const String& classNames);
+    ClassNodeList(Node& rootNode, const String& classNames);
 
     virtual bool nodeMatches(Element*) const;
 
 
     virtual bool nodeMatches(Element*) const;
 
index db4be17e9458e92cf2a44a161cd845b672e819fb..834238b06f0753f677d26e0d52cc0d7576d21fdc 100644 (file)
@@ -4365,7 +4365,7 @@ bool Document::hasSVGRootNode() const
 
 PassRefPtr<HTMLCollection> Document::ensureCachedCollection(CollectionType type)
 {
 
 PassRefPtr<HTMLCollection> Document::ensureCachedCollection(CollectionType type)
 {
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLCollection>(this, type);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLCollection>(*this, type);
 }
 
 PassRefPtr<HTMLCollection> Document::images()
 }
 
 PassRefPtr<HTMLCollection> Document::images()
@@ -4411,17 +4411,17 @@ PassRefPtr<HTMLCollection> Document::anchors()
 
 PassRefPtr<HTMLCollection> Document::all()
 {
 
 PassRefPtr<HTMLCollection> Document::all()
 {
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLAllCollection>(this, DocAll);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLAllCollection>(*this, DocAll);
 }
 
 PassRefPtr<HTMLCollection> Document::windowNamedItems(const AtomicString& name)
 {
 }
 
 PassRefPtr<HTMLCollection> Document::windowNamedItems(const AtomicString& name)
 {
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<WindowNameCollection>(this, WindowNamedItems, name);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<WindowNameCollection>(*this, WindowNamedItems, name);
 }
 
 PassRefPtr<HTMLCollection> Document::documentNamedItems(const AtomicString& name)
 {
 }
 
 PassRefPtr<HTMLCollection> Document::documentNamedItems(const AtomicString& name)
 {
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<DocumentNameCollection>(this, DocumentNamedItems, name);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<DocumentNameCollection>(*this, DocumentNamedItems, name);
 }
 
 void Document::finishedParsing()
 }
 
 void Document::finishedParsing()
index 869dd2b3c735a8a59bb828d0ea8ed7786cc6cb29..e25a010d84c8ff985377a3517ab49118571944aa 100644 (file)
@@ -2929,15 +2929,15 @@ PassRefPtr<HTMLCollection> Element::ensureCachedHTMLCollection(CollectionType ty
     RefPtr<HTMLCollection> collection;
     if (type == TableRows) {
         ASSERT(hasTagName(tableTag));
     RefPtr<HTMLCollection> collection;
     if (type == TableRows) {
         ASSERT(hasTagName(tableTag));
-        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLTableRowsCollection>(this, type);
+        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLTableRowsCollection>(*this, type);
     } else if (type == SelectOptions) {
         ASSERT(hasTagName(selectTag));
     } else if (type == SelectOptions) {
         ASSERT(hasTagName(selectTag));
-        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLOptionsCollection>(this, type);
+        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLOptionsCollection>(*this, type);
     } else if (type == FormControls) {
         ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
     } else if (type == FormControls) {
         ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
-        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLFormControlsCollection>(this, type);
+        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLFormControlsCollection>(*this, type);
     }
     }
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLCollection>(this, type);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLCollection>(*this, type);
 }
 
 HTMLCollection* Element::cachedHTMLCollection(CollectionType type)
 }
 
 HTMLCollection* Element::cachedHTMLCollection(CollectionType type)
index 1edfa19f2cc9d17a2319541b13042128d65ef6fc..f370a8ff2cf8534bf677b510252e2cd5b53b8209 100644 (file)
@@ -31,10 +31,10 @@ namespace WebCore {
 
 Node* LiveNodeListBase::rootNode() const
 {
 
 Node* LiveNodeListBase::rootNode() const
 {
-    if (isRootedAtDocument() && m_ownerNode->inDocument())
-        return &m_ownerNode->document();
+    if (isRootedAtDocument() && ownerNode().inDocument())
+        return &ownerNode().document();
 
 
-    return m_ownerNode.get();
+    return &ownerNode();
 }
 
 ContainerNode* LiveNodeListBase::rootContainerNode() const
 }
 
 ContainerNode* LiveNodeListBase::rootContainerNode() const
index c2dcb18ec817a35d6a6a6eb76f20321060d72e9c..f931700e502f83d33bb8a290bf4e61ca1c386fe4 100644 (file)
@@ -48,7 +48,7 @@ public:
         DoesNotOverrideItemAfter,
     };
 
         DoesNotOverrideItemAfter,
     };
 
-    LiveNodeListBase(Node* ownerNode, NodeListRootType rootType, NodeListInvalidationType invalidationType,
+    LiveNodeListBase(Node& ownerNode, NodeListRootType rootType, NodeListInvalidationType invalidationType,
         bool shouldOnlyIncludeDirectChildren, CollectionType collectionType, ItemAfterOverrideType itemAfterOverrideType)
         : m_ownerNode(ownerNode)
         , m_cachedItem(0)
         bool shouldOnlyIncludeDirectChildren, CollectionType collectionType, ItemAfterOverrideType itemAfterOverrideType)
         : m_ownerNode(ownerNode)
         , m_cachedItem(0)
@@ -85,7 +85,7 @@ public:
     ALWAYS_INLINE bool isRootedAtDocument() const { return m_rootType == NodeListIsRootedAtDocument || m_rootType == NodeListIsRootedAtDocumentIfOwnerHasItemrefAttr; }
     ALWAYS_INLINE NodeListInvalidationType invalidationType() const { return static_cast<NodeListInvalidationType>(m_invalidationType); }
     ALWAYS_INLINE CollectionType type() const { return static_cast<CollectionType>(m_collectionType); }
     ALWAYS_INLINE bool isRootedAtDocument() const { return m_rootType == NodeListIsRootedAtDocument || m_rootType == NodeListIsRootedAtDocumentIfOwnerHasItemrefAttr; }
     ALWAYS_INLINE NodeListInvalidationType invalidationType() const { return static_cast<NodeListInvalidationType>(m_invalidationType); }
     ALWAYS_INLINE CollectionType type() const { return static_cast<CollectionType>(m_collectionType); }
-    Node* ownerNode() const { return m_ownerNode.get(); }
+    Node& ownerNode() const { return const_cast<Node&>(m_ownerNode.get()); }
     ALWAYS_INLINE void invalidateCache(const QualifiedName* attrName) const
     {
         if (!attrName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attrName))
     ALWAYS_INLINE void invalidateCache(const QualifiedName* attrName) const
     {
         if (!attrName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attrName))
@@ -144,7 +144,7 @@ private:
     Node* iterateForPreviousNode(Node* current) const;
     Node* itemBefore(Node* previousItem) const;
 
     Node* iterateForPreviousNode(Node* current) const;
     Node* itemBefore(Node* previousItem) const;
 
-    RefPtr<Node> m_ownerNode;
+    Ref<Node> m_ownerNode;
     mutable Node* m_cachedItem;
     mutable unsigned m_cachedLength;
     mutable unsigned m_cachedItemOffset;
     mutable Node* m_cachedItem;
     mutable unsigned m_cachedLength;
     mutable unsigned m_cachedItemOffset;
@@ -187,8 +187,8 @@ ALWAYS_INLINE bool LiveNodeListBase::shouldInvalidateTypeOnAttributeChange(NodeL
 
 class LiveNodeList : public LiveNodeListBase {
 public:
 
 class LiveNodeList : public LiveNodeListBase {
 public:
-    LiveNodeList(PassRefPtr<Node> ownerNode, CollectionType collectionType, NodeListInvalidationType invalidationType, NodeListRootType rootType = NodeListIsRootedAtNode)
-        : LiveNodeListBase(ownerNode.get(), rootType, invalidationType, collectionType == ChildNodeListType,
+    LiveNodeList(Node& ownerNode, CollectionType collectionType, NodeListInvalidationType invalidationType, NodeListRootType rootType = NodeListIsRootedAtNode)
+        : LiveNodeListBase(ownerNode, rootType, invalidationType, collectionType == ChildNodeListType,
         collectionType, DoesNotOverrideItemAfter)
     { }
 
         collectionType, DoesNotOverrideItemAfter)
     { }
 
index b66d4937caa305177a933f6c1fba96e7f3dca4e6..c67c2a94c1fe83751dd51d5c474c9d1e21211cf8 100644 (file)
@@ -32,7 +32,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
 
 using namespace HTMLNames;
 
-NameNodeList::NameNodeList(PassRefPtr<Node> rootNode, const AtomicString& name)
+NameNodeList::NameNodeList(Node& rootNode, const AtomicString& name)
     : LiveNodeList(rootNode, NameNodeListType, InvalidateOnNameAttrChange)
     , m_name(name)
 {
     : LiveNodeList(rootNode, NameNodeListType, InvalidateOnNameAttrChange)
     , m_name(name)
 {
@@ -40,7 +40,7 @@ NameNodeList::NameNodeList(PassRefPtr<Node> rootNode, const AtomicString& name)
 
 NameNodeList::~NameNodeList()
 {
 
 NameNodeList::~NameNodeList()
 {
-    ownerNode()->nodeLists()->removeCacheWithAtomicName(this, NameNodeListType, m_name);
+    ownerNode().nodeLists()->removeCacheWithAtomicName(this, NameNodeListType, m_name);
 } 
 
 bool NameNodeList::nodeMatches(Element* testNode) const
 } 
 
 bool NameNodeList::nodeMatches(Element* testNode) const
index a7f7c14706e9ecb4261d59a4f993cad3fada5315..c1ce289ff0eff94ea376958aa4e582f41d815a93 100644 (file)
@@ -33,7 +33,7 @@ namespace WebCore {
 // NodeList which lists all Nodes in a Element with a given "name" attribute
 class NameNodeList : public LiveNodeList {
 public:
 // NodeList which lists all Nodes in a Element with a given "name" attribute
 class NameNodeList : public LiveNodeList {
 public:
-    static PassRefPtr<NameNodeList> create(PassRefPtr<Node> rootNode, CollectionType type, const AtomicString& name)
+    static PassRefPtr<NameNodeList> create(Node& rootNode, CollectionType type, const AtomicString& name)
     {
         ASSERT_UNUSED(type, type == NameNodeListType);
         return adoptRef(new NameNodeList(rootNode, name));
     {
         ASSERT_UNUSED(type, type == NameNodeListType);
         return adoptRef(new NameNodeList(rootNode, name));
@@ -42,7 +42,7 @@ public:
     virtual ~NameNodeList();
 
 private:
     virtual ~NameNodeList();
 
 private:
-    NameNodeList(PassRefPtr<Node> rootNode, const AtomicString& name);
+    NameNodeList(Node& rootNode, const AtomicString& name);
 
     virtual bool nodeMatches(Element*) const;
 
 
     virtual bool nodeMatches(Element*) const;
 
index 980d4c919169642f0c8aa4b31f494c8f5a7cbfd6..dd8c9d897531e36dfa5f62f29e0047bc1f5820b1 100644 (file)
@@ -442,7 +442,7 @@ void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
 
 PassRefPtr<NodeList> Node::childNodes()
 {
 
 PassRefPtr<NodeList> Node::childNodes()
 {
-    return ensureRareData().ensureNodeLists().ensureChildNodeList(this);
+    return ensureRareData().ensureNodeLists().ensureChildNodeList(*this);
 }
 
 Node *Node::lastDescendant() const
 }
 
 Node *Node::lastDescendant() const
@@ -1075,8 +1075,8 @@ PassRefPtr<NodeList> Node::getElementsByTagName(const AtomicString& localName)
         return 0;
 
     if (document().isHTMLDocument())
         return 0;
 
     if (document().isHTMLDocument())
-        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLTagNodeList>(this, HTMLTagNodeListType, localName);
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<TagNodeList>(this, TagNodeListType, localName);
+        return ensureRareData().ensureNodeLists().addCacheWithAtomicName<HTMLTagNodeList>(*this, HTMLTagNodeListType, localName);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<TagNodeList>(*this, TagNodeListType, localName);
 }
 
 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName)
 }
 
 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName)
@@ -1087,23 +1087,23 @@ PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceU
     if (namespaceURI == starAtom)
         return getElementsByTagName(localName);
 
     if (namespaceURI == starAtom)
         return getElementsByTagName(localName);
 
-    return ensureRareData().ensureNodeLists().addCacheWithQualifiedName(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localName);
+    return ensureRareData().ensureNodeLists().addCacheWithQualifiedName(*this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localName);
 }
 
 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
 {
 }
 
 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
 {
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<NameNodeList>(this, NameNodeListType, elementName);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<NameNodeList>(*this, NameNodeListType, elementName);
 }
 
 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
 {
 }
 
 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
 {
-    return ensureRareData().ensureNodeLists().addCacheWithName<ClassNodeList>(this, ClassNodeListType, classNames);
+    return ensureRareData().ensureNodeLists().addCacheWithName<ClassNodeList>(*this, ClassNodeListType, classNames);
 }
 
 PassRefPtr<RadioNodeList> Node::radioNodeList(const AtomicString& name)
 {
     ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
 }
 
 PassRefPtr<RadioNodeList> Node::radioNodeList(const AtomicString& name)
 {
     ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<RadioNodeList>(this, RadioNodeListType, name);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<RadioNodeList>(*this, RadioNodeListType, name);
 }
 
 PassRefPtr<Element> Node::querySelector(const AtomicString& selectors, ExceptionCode& ec)
 }
 
 PassRefPtr<Element> Node::querySelector(const AtomicString& selectors, ExceptionCode& ec)
index b7e51c71e664daf85081a35e9d84be06a623057b..259eefe429ef51fb1184b39a02d851a02f611303 100644 (file)
@@ -55,7 +55,7 @@ public:
             m_childNodeList->invalidateCache();
     }
 
             m_childNodeList->invalidateCache();
     }
 
-    PassRefPtr<ChildNodeList> ensureChildNodeList(Node* node)
+    PassRefPtr<ChildNodeList> ensureChildNodeList(Node& node)
     {
         if (m_childNodeList)
             return m_childNodeList;
     {
         if (m_childNodeList)
             return m_childNodeList;
@@ -87,7 +87,7 @@ public:
     typedef HashMap<QualifiedName, TagNodeList*> TagNodeListCacheNS;
 
     template<typename T>
     typedef HashMap<QualifiedName, TagNodeList*> TagNodeListCacheNS;
 
     template<typename T>
-    PassRefPtr<T> addCacheWithAtomicName(Node* node, CollectionType collectionType, const AtomicString& name)
+    PassRefPtr<T> addCacheWithAtomicName(Node& node, CollectionType collectionType, const AtomicString& name)
     {
         NodeListAtomicNameCacheMap::AddResult result = m_atomicNameCaches.add(namedNodeListKey(collectionType, name), nullptr);
         if (!result.isNewEntry)
     {
         NodeListAtomicNameCacheMap::AddResult result = m_atomicNameCaches.add(namedNodeListKey(collectionType, name), nullptr);
         if (!result.isNewEntry)
@@ -100,7 +100,7 @@ public:
 
     // FIXME: This function should be renamed since it doesn't have an atomic name.
     template<typename T>
 
     // FIXME: This function should be renamed since it doesn't have an atomic name.
     template<typename T>
-    PassRefPtr<T> addCacheWithAtomicName(Node* node, CollectionType collectionType)
+    PassRefPtr<T> addCacheWithAtomicName(Node& node, CollectionType collectionType)
     {
         NodeListAtomicNameCacheMap::AddResult result = m_atomicNameCaches.add(namedNodeListKey(collectionType, starAtom), nullptr);
         if (!result.isNewEntry)
     {
         NodeListAtomicNameCacheMap::AddResult result = m_atomicNameCaches.add(namedNodeListKey(collectionType, starAtom), nullptr);
         if (!result.isNewEntry)
@@ -118,7 +118,7 @@ public:
     }
 
     template<typename T>
     }
 
     template<typename T>
-    PassRefPtr<T> addCacheWithName(Node* node, CollectionType collectionType, const String& name)
+    PassRefPtr<T> addCacheWithName(Node& node, CollectionType collectionType, const String& name)
     {
         NodeListNameCacheMap::AddResult result = m_nameCaches.add(namedNodeListKey(collectionType, name), nullptr);
         if (!result.isNewEntry)
     {
         NodeListNameCacheMap::AddResult result = m_nameCaches.add(namedNodeListKey(collectionType, name), nullptr);
         if (!result.isNewEntry)
@@ -129,7 +129,7 @@ public:
         return list.release();
     }
 
         return list.release();
     }
 
-    PassRefPtr<TagNodeList> addCacheWithQualifiedName(Node* node, const AtomicString& namespaceURI, const AtomicString& localName)
+    PassRefPtr<TagNodeList> addCacheWithQualifiedName(Node& node, const AtomicString& namespaceURI, const AtomicString& localName)
     {
         QualifiedName name(nullAtom, localName, namespaceURI);
         TagNodeListCacheNS::AddResult result = m_tagNodeListCacheNS.add(name, nullptr);
     {
         QualifiedName name(nullAtom, localName, namespaceURI);
         TagNodeListCacheNS::AddResult result = m_tagNodeListCacheNS.add(name, nullptr);
@@ -226,7 +226,7 @@ private:
         return std::pair<unsigned char, String>(type, name);
     }
 
         return std::pair<unsigned char, String>(type, name);
     }
 
-    bool deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node*);
+    bool deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node&);
 
     // FIXME: m_childNodeList should be merged into m_atomicNameCaches or at least be shared with HTMLCollection returned by Element::children
     // but it's tricky because invalidateCaches shouldn't invalidate this cache and adoptTreeScope shouldn't call registerNodeList or unregisterNodeList.
 
     // FIXME: m_childNodeList should be merged into m_atomicNameCaches or at least be shared with HTMLCollection returned by Element::children
     // but it's tricky because invalidateCaches shouldn't invalidate this cache and adoptTreeScope shouldn't call registerNodeList or unregisterNodeList.
@@ -295,13 +295,12 @@ private:
     OwnPtr<NodeMutationObserverData> m_mutationObserverData;
 };
 
     OwnPtr<NodeMutationObserverData> m_mutationObserverData;
 };
 
-inline bool NodeListsNodeData::deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node* ownerNode)
+inline bool NodeListsNodeData::deleteThisAndUpdateNodeRareDataIfAboutToRemoveLastList(Node& ownerNode)
 {
 {
-    ASSERT(ownerNode);
-    ASSERT(ownerNode->nodeLists() == this);
+    ASSERT(ownerNode.nodeLists() == this);
     if ((m_childNodeList ? 1 : 0) + m_atomicNameCaches.size() + m_nameCaches.size() + m_tagNodeListCacheNS.size() != 1)
         return false;
     if ((m_childNodeList ? 1 : 0) + m_atomicNameCaches.size() + m_nameCaches.size() + m_tagNodeListCacheNS.size() != 1)
         return false;
-    ownerNode->clearNodeLists();
+    ownerNode.clearNodeLists();
     return true;
 }
 
     return true;
 }
 
index b10a576609d0cbc9262663f2fbcdc9cd4d12732c..eacd0c93fb6e6722f4555c5ea5e20be5dd91e7c0 100644 (file)
@@ -30,7 +30,7 @@
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-TagNodeList::TagNodeList(PassRefPtr<Node> rootNode, CollectionType type, const AtomicString& namespaceURI, const AtomicString& localName)
+TagNodeList::TagNodeList(Node& rootNode, CollectionType type, const AtomicString& namespaceURI, const AtomicString& localName)
     : LiveNodeList(rootNode, type, DoNotInvalidateOnAttributeChanges)
     , m_namespaceURI(namespaceURI)
     , m_localName(localName)
     : LiveNodeList(rootNode, type, DoNotInvalidateOnAttributeChanges)
     , m_namespaceURI(namespaceURI)
     , m_localName(localName)
@@ -41,9 +41,9 @@ TagNodeList::TagNodeList(PassRefPtr<Node> rootNode, CollectionType type, const A
 TagNodeList::~TagNodeList()
 {
     if (m_namespaceURI == starAtom)
 TagNodeList::~TagNodeList()
 {
     if (m_namespaceURI == starAtom)
-        ownerNode()->nodeLists()->removeCacheWithAtomicName(this, type(), m_localName);
+        ownerNode().nodeLists()->removeCacheWithAtomicName(this, type(), m_localName);
     else
     else
-        ownerNode()->nodeLists()->removeCacheWithQualifiedName(this, m_namespaceURI, m_localName);
+        ownerNode().nodeLists()->removeCacheWithQualifiedName(this, m_namespaceURI, m_localName);
 }
 
 bool TagNodeList::nodeMatches(Element* testNode) const
 }
 
 bool TagNodeList::nodeMatches(Element* testNode) const
@@ -55,7 +55,7 @@ bool TagNodeList::nodeMatches(Element* testNode) const
     return m_namespaceURI == starAtom || m_namespaceURI == testNode->namespaceURI();
 }
 
     return m_namespaceURI == starAtom || m_namespaceURI == testNode->namespaceURI();
 }
 
-HTMLTagNodeList::HTMLTagNodeList(PassRefPtr<Node> rootNode, const AtomicString& localName)
+HTMLTagNodeList::HTMLTagNodeList(Node& rootNode, const AtomicString& localName)
     : TagNodeList(rootNode, HTMLTagNodeListType, starAtom, localName)
     , m_loweredLocalName(localName.lower())
 {
     : TagNodeList(rootNode, HTMLTagNodeListType, starAtom, localName)
     , m_loweredLocalName(localName.lower())
 {
index 55b8aa93a91df4b57144a67e5ca3c5a29c5d2fae..89189e3a9691a06b2c60ed84b3dd9d5bd42564b9 100644 (file)
@@ -33,13 +33,13 @@ namespace WebCore {
 // NodeList that limits to a particular tag.
 class TagNodeList : public LiveNodeList {
 public:
 // NodeList that limits to a particular tag.
 class TagNodeList : public LiveNodeList {
 public:
-    static PassRefPtr<TagNodeList> create(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName)
+    static PassRefPtr<TagNodeList> create(Node& rootNode, const AtomicString& namespaceURI, const AtomicString& localName)
     {
         ASSERT(namespaceURI != starAtom);
         return adoptRef(new TagNodeList(rootNode, TagNodeListType, namespaceURI, localName));
     }
 
     {
         ASSERT(namespaceURI != starAtom);
         return adoptRef(new TagNodeList(rootNode, TagNodeListType, namespaceURI, localName));
     }
 
-    static PassRefPtr<TagNodeList> create(PassRefPtr<Node> rootNode, CollectionType type, const AtomicString& localName)
+    static PassRefPtr<TagNodeList> create(Node& rootNode, CollectionType type, const AtomicString& localName)
     {
         ASSERT_UNUSED(type, type == TagNodeListType);
         return adoptRef(new TagNodeList(rootNode, TagNodeListType, starAtom, localName));
     {
         ASSERT_UNUSED(type, type == TagNodeListType);
         return adoptRef(new TagNodeList(rootNode, TagNodeListType, starAtom, localName));
@@ -48,7 +48,7 @@ public:
     virtual ~TagNodeList();
 
 protected:
     virtual ~TagNodeList();
 
 protected:
-    TagNodeList(PassRefPtr<Node> rootNode, CollectionType, const AtomicString& namespaceURI, const AtomicString& localName);
+    TagNodeList(Node& rootNode, CollectionType, const AtomicString& namespaceURI, const AtomicString& localName);
 
     virtual bool nodeMatches(Element*) const OVERRIDE;
 
 
     virtual bool nodeMatches(Element*) const OVERRIDE;
 
@@ -58,7 +58,7 @@ protected:
 
 class HTMLTagNodeList : public TagNodeList {
 public:
 
 class HTMLTagNodeList : public TagNodeList {
 public:
-    static PassRefPtr<HTMLTagNodeList> create(PassRefPtr<Node> rootNode, CollectionType type, const AtomicString& localName)
+    static PassRefPtr<HTMLTagNodeList> create(Node& rootNode, CollectionType type, const AtomicString& localName)
     {
         ASSERT_UNUSED(type, type == HTMLTagNodeListType);
         return adoptRef(new HTMLTagNodeList(rootNode, localName));
     {
         ASSERT_UNUSED(type, type == HTMLTagNodeListType);
         return adoptRef(new HTMLTagNodeList(rootNode, localName));
@@ -67,7 +67,7 @@ public:
     bool nodeMatchesInlined(Element*) const;
 
 private:
     bool nodeMatchesInlined(Element*) const;
 
 private:
-    HTMLTagNodeList(PassRefPtr<Node> rootNode, const AtomicString& localName);
+    HTMLTagNodeList(Node& rootNode, const AtomicString& localName);
 
     virtual bool nodeMatches(Element*) const OVERRIDE;
 
 
     virtual bool nodeMatches(Element*) const OVERRIDE;
 
index 465fa1c7b05723f52ca9caefd4b12c81cd66cbd6..d7b5a3fc7bb46f0ad368f6ba1433b22b376a09ed 100644 (file)
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-PassRefPtr<HTMLAllCollection> HTMLAllCollection::create(Node* node, CollectionType type)
+PassRefPtr<HTMLAllCollection> HTMLAllCollection::create(Node& node, CollectionType type)
 {
     return adoptRef(new HTMLAllCollection(node, type));
 }
 
 {
     return adoptRef(new HTMLAllCollection(node, type));
 }
 
-HTMLAllCollection::HTMLAllCollection(Node* node, CollectionType type)
+HTMLAllCollection::HTMLAllCollection(Node& node, CollectionType type)
     : HTMLCollection(node, type, DoesNotOverrideItemAfter)
 {
 }
     : HTMLCollection(node, type, DoesNotOverrideItemAfter)
 {
 }
index 62e26419f4dfde25161d41dfdd564e2a8aae1480..8989e74087f0105d803ce3bc74754e92913384a4 100644 (file)
@@ -32,13 +32,13 @@ namespace WebCore {
 
 class HTMLAllCollection : public HTMLCollection {
 public:
 
 class HTMLAllCollection : public HTMLCollection {
 public:
-    static PassRefPtr<HTMLAllCollection> create(Node*, CollectionType);
+    static PassRefPtr<HTMLAllCollection> create(Node&, CollectionType);
     virtual ~HTMLAllCollection();
 
     Node* namedItemWithIndex(const AtomicString& name, unsigned index) const;
 
 private:
     virtual ~HTMLAllCollection();
 
     Node* namedItemWithIndex(const AtomicString& name, unsigned index) const;
 
 private:
-    HTMLAllCollection(Node*, CollectionType);
+    HTMLAllCollection(Node&, CollectionType);
 };
 
 } // namespace WebCore
 };
 
 } // namespace WebCore
index 555683e82d154569632d0931622a68cdf0a360e5..614b5df2784a2d77618a8f5e934a32e8e0e2e762 100644 (file)
@@ -158,13 +158,13 @@ static NodeListInvalidationType invalidationTypeExcludingIdAndNameAttributes(Col
     return DoNotInvalidateOnAttributeChanges;
 }
 
     return DoNotInvalidateOnAttributeChanges;
 }
 
-HTMLCollection::HTMLCollection(Node* ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
+HTMLCollection::HTMLCollection(Node& ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type),
         WebCore::shouldOnlyIncludeDirectChildren(type), type, itemAfterOverrideType)
 {
 }
 
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type),
         WebCore::shouldOnlyIncludeDirectChildren(type), type, itemAfterOverrideType)
 {
 }
 
-PassRefPtr<HTMLCollection> HTMLCollection::create(Node* base, CollectionType type)
+PassRefPtr<HTMLCollection> HTMLCollection::create(Node& base, CollectionType type)
 {
     return adoptRef(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
 }
 {
     return adoptRef(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
 }
@@ -173,7 +173,7 @@ HTMLCollection::~HTMLCollection()
 {
     // HTMLNameCollection removes cache by itself.
     if (type() != WindowNamedItems && type() != DocumentNamedItems)
 {
     // HTMLNameCollection removes cache by itself.
     if (type() != WindowNamedItems && type() != DocumentNamedItems)
-        ownerNode()->nodeLists()->removeCacheWithAtomicName(this, type());
+        ownerNode().nodeLists()->removeCacheWithAtomicName(this, type());
 }
 
 template <class NodeListType>
 }
 
 template <class NodeListType>
@@ -666,7 +666,7 @@ void HTMLCollection::namedItems(const AtomicString& name, Vector<Ref<Element>>&
 
 PassRefPtr<NodeList> HTMLCollection::tags(const String& name)
 {
 
 PassRefPtr<NodeList> HTMLCollection::tags(const String& name)
 {
-    return ownerNode()->getElementsByTagName(name);
+    return ownerNode().getElementsByTagName(name);
 }
 
 void HTMLCollection::append(NodeCacheMap& map, const AtomicString& key, Element* element)
 }
 
 void HTMLCollection::append(NodeCacheMap& map, const AtomicString& key, Element* element)
index 7f21f82ea4d48cd92f2ca012dfa705cfcdf7a209..e1cad3f9c8c8cee8452b74b25154a00f304b8ecf 100644 (file)
@@ -34,7 +34,7 @@ namespace WebCore {
 
 class HTMLCollection : public LiveNodeListBase {
 public:
 
 class HTMLCollection : public LiveNodeListBase {
 public:
-    static PassRefPtr<HTMLCollection> create(Node* base, CollectionType);
+    static PassRefPtr<HTMLCollection> create(Node& base, CollectionType);
     virtual ~HTMLCollection();
 
     // DOM API
     virtual ~HTMLCollection();
 
     // DOM API
@@ -67,7 +67,7 @@ public:
     Element* traverseForwardToOffset(unsigned offset, Element* currentElement, unsigned& currentOffset, unsigned& offsetInArray, ContainerNode* root) const;
 
 protected:
     Element* traverseForwardToOffset(unsigned offset, Element* currentElement, unsigned& currentOffset, unsigned& offsetInArray, ContainerNode* root) const;
 
 protected:
-    HTMLCollection(Node* base, CollectionType, ItemAfterOverrideType);
+    HTMLCollection(Node& base, CollectionType, ItemAfterOverrideType);
 
     virtual void updateNameCache() const;
 
 
     virtual void updateNameCache() const;
 
index 0ea63bcbb676926959b8a63a1d5aa92338659b2e..9f78227e5aef92b67fda0aed2c41e3df344a7a27 100644 (file)
@@ -36,13 +36,13 @@ using namespace HTMLNames;
 // Since the collections are to be "live", we have to do the
 // calculation every time if anything has changed.
 
 // Since the collections are to be "live", we have to do the
 // calculation every time if anything has changed.
 
-HTMLFormControlsCollection::HTMLFormControlsCollection(Node* ownerNode)
+HTMLFormControlsCollection::HTMLFormControlsCollection(Node& ownerNode)
     : HTMLCollection(ownerNode, FormControls, OverridesItemAfter)
 {
     : HTMLCollection(ownerNode, FormControls, OverridesItemAfter)
 {
-    ASSERT(isHTMLFormElement(ownerNode) || ownerNode->hasTagName(fieldsetTag));
+    ASSERT(isHTMLFormElement(ownerNode) || isHTMLFieldSetElement(ownerNode));
 }
 
 }
 
-PassRefPtr<HTMLFormControlsCollection> HTMLFormControlsCollection::create(Node* ownerNode, CollectionType)
+PassRefPtr<HTMLFormControlsCollection> HTMLFormControlsCollection::create(Node& ownerNode, CollectionType)
 {
     return adoptRef(new HTMLFormControlsCollection(ownerNode));
 }
 {
     return adoptRef(new HTMLFormControlsCollection(ownerNode));
 }
@@ -53,18 +53,16 @@ HTMLFormControlsCollection::~HTMLFormControlsCollection()
 
 const Vector<FormAssociatedElement*>& HTMLFormControlsCollection::formControlElements() const
 {
 
 const Vector<FormAssociatedElement*>& HTMLFormControlsCollection::formControlElements() const
 {
-    ASSERT(ownerNode());
-    ASSERT(isHTMLFormElement(ownerNode()) || ownerNode()->hasTagName(fieldsetTag));
+    ASSERT(isHTMLFormElement(ownerNode()) || ownerNode().hasTagName(fieldsetTag));
     if (isHTMLFormElement(ownerNode()))
     if (isHTMLFormElement(ownerNode()))
-        return toHTMLFormElement(ownerNode())->associatedElements();
-    return static_cast<HTMLFieldSetElement*>(ownerNode())->associatedElements();
+        return toHTMLFormElement(ownerNode()).associatedElements();
+    return toHTMLFieldSetElement(ownerNode()).associatedElements();
 }
 
 const Vector<HTMLImageElement*>& HTMLFormControlsCollection::formImageElements() const
 {
 }
 
 const Vector<HTMLImageElement*>& HTMLFormControlsCollection::formImageElements() const
 {
-    ASSERT(ownerNode());
     ASSERT(isHTMLFormElement(ownerNode()));
     ASSERT(isHTMLFormElement(ownerNode()));
-    return toHTMLFormElement(ownerNode())->imageElements();
+    return toHTMLFormElement(ownerNode()).imageElements();
 }
 
 Element* HTMLFormControlsCollection::virtualItemAfter(unsigned& offset, Element* previousItem) const
 }
 
 Element* HTMLFormControlsCollection::virtualItemAfter(unsigned& offset, Element* previousItem) const
@@ -111,7 +109,7 @@ Node* HTMLFormControlsCollection::namedItem(const AtomicString& name) const
     // attribute. If a match is not found, the method then searches for an
     // object with a matching name attribute, but only on those elements
     // that are allowed a name attribute.
     // attribute. If a match is not found, the method then searches for an
     // object with a matching name attribute, but only on those elements
     // that are allowed a name attribute.
-    const Vector<HTMLImageElement*>* imagesElements = ownerNode()->hasTagName(fieldsetTag) ? 0 : &formImageElements();
+    const Vector<HTMLImageElement*>* imagesElements = ownerNode().hasTagName(fieldsetTag) ? 0 : &formImageElements();
     if (HTMLElement* item = firstNamedItem(formControlElements(), imagesElements, idAttr, name))
         return item;
 
     if (HTMLElement* item = firstNamedItem(formControlElements(), imagesElements, idAttr, name))
         return item;
 
index cef0f14d51b5da7d5a56f1a4820663ce5c03a208..7742047e4c43da6a383c89fb5b46c856dbfc464e 100644 (file)
@@ -37,14 +37,14 @@ class QualifiedName;
 
 class HTMLFormControlsCollection : public HTMLCollection {
 public:
 
 class HTMLFormControlsCollection : public HTMLCollection {
 public:
-    static PassRefPtr<HTMLFormControlsCollection> create(Node*, CollectionType);
+    static PassRefPtr<HTMLFormControlsCollection> create(Node&, CollectionType);
 
     virtual ~HTMLFormControlsCollection();
 
     virtual Node* namedItem(const AtomicString& name) const;
 
 private:
 
     virtual ~HTMLFormControlsCollection();
 
     virtual Node* namedItem(const AtomicString& name) const;
 
 private:
-    HTMLFormControlsCollection(Node*);
+    explicit HTMLFormControlsCollection(Node&);
 
     virtual void updateNameCache() const;
 
 
     virtual void updateNameCache() const;
 
index 8a5c24cefc08a3aa7ab93fd70f635229c52ad4ce..4ed01c2d02adba18758ea393d1aa359544da724a 100644 (file)
@@ -36,7 +36,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
 
 using namespace HTMLNames;
 
-HTMLNameCollection::HTMLNameCollection(Node* document, CollectionType type, const AtomicString& name)
+HTMLNameCollection::HTMLNameCollection(Node& document, CollectionType type, const AtomicString& name)
     : HTMLCollection(document, type, DoesNotOverrideItemAfter)
     , m_name(name)
 {
     : HTMLCollection(document, type, DoesNotOverrideItemAfter)
     , m_name(name)
 {
@@ -44,11 +44,10 @@ HTMLNameCollection::HTMLNameCollection(Node* document, CollectionType type, cons
 
 HTMLNameCollection::~HTMLNameCollection()
 {
 
 HTMLNameCollection::~HTMLNameCollection()
 {
-    ASSERT(ownerNode());
-    ASSERT(ownerNode()->isDocumentNode());
+    ASSERT(ownerNode().isDocumentNode());
     ASSERT(type() == WindowNamedItems || type() == DocumentNamedItems);
 
     ASSERT(type() == WindowNamedItems || type() == DocumentNamedItems);
 
-    ownerNode()->nodeLists()->removeCacheWithAtomicName(this, type(), m_name);
+    ownerNode().nodeLists()->removeCacheWithAtomicName(this, type(), m_name);
 }
 
 bool WindowNameCollection::nodeMatchesIfNameAttributeMatch(Element* element)
 }
 
 bool WindowNameCollection::nodeMatchesIfNameAttributeMatch(Element* element)
index d2e5cc29f9748702dc021b9e1421b2febf2a3bcb..e17e581df99ef66d4a3869cc25541943f2598994 100644 (file)
@@ -36,14 +36,14 @@ public:
     ~HTMLNameCollection();
 
 protected:
     ~HTMLNameCollection();
 
 protected:
-    HTMLNameCollection(Node*, CollectionType, const AtomicString& name);
+    HTMLNameCollection(Node&, CollectionType, const AtomicString& name);
 
     AtomicString m_name;
 };
 
 class WindowNameCollection : public HTMLNameCollection {
 public:
 
     AtomicString m_name;
 };
 
 class WindowNameCollection : public HTMLNameCollection {
 public:
-    static PassRefPtr<WindowNameCollection> create(Node* document, CollectionType type, const AtomicString& name)
+    static PassRefPtr<WindowNameCollection> create(Node& document, CollectionType type, const AtomicString& name)
     {
         return adoptRef(new WindowNameCollection(document, type, name));
     }
     {
         return adoptRef(new WindowNameCollection(document, type, name));
     }
@@ -55,7 +55,7 @@ public:
     static bool nodeMatches(Element*, const AtomicStringImpl*);
 
 private:
     static bool nodeMatches(Element*, const AtomicStringImpl*);
 
 private:
-    WindowNameCollection(Node* document, CollectionType type, const AtomicString& name)
+    WindowNameCollection(Node& document, CollectionType type, const AtomicString& name)
         : HTMLNameCollection(document, type, name)
     {
         ASSERT(type == WindowNamedItems);
         : HTMLNameCollection(document, type, name)
     {
         ASSERT(type == WindowNamedItems);
@@ -64,7 +64,7 @@ private:
 
 class DocumentNameCollection : public HTMLNameCollection {
 public:
 
 class DocumentNameCollection : public HTMLNameCollection {
 public:
-    static PassRefPtr<DocumentNameCollection> create(Node* document, CollectionType type, const AtomicString& name)
+    static PassRefPtr<DocumentNameCollection> create(Node& document, CollectionType type, const AtomicString& name)
     {
         return adoptRef(new DocumentNameCollection(document, type, name));
     }
     {
         return adoptRef(new DocumentNameCollection(document, type, name));
     }
@@ -76,7 +76,7 @@ public:
     static bool nodeMatches(Element*, const AtomicStringImpl*);
 
 private:
     static bool nodeMatches(Element*, const AtomicStringImpl*);
 
 private:
-    DocumentNameCollection(Node* document, CollectionType type, const AtomicString& name)
+    DocumentNameCollection(Node& document, CollectionType type, const AtomicString& name)
         : HTMLNameCollection(document, type, name)
     {
         ASSERT(type == DocumentNamedItems);
         : HTMLNameCollection(document, type, name)
     {
         ASSERT(type == DocumentNamedItems);
index 71b67b9e6ff96c84ef5172bfa75d9692432683e1..01b2210a1e53d170ffffc21617ea8f6b29d316f9 100644 (file)
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-HTMLOptionsCollection::HTMLOptionsCollection(Node* select)
+HTMLOptionsCollection::HTMLOptionsCollection(Node& select)
     : HTMLCollection(select, SelectOptions, DoesNotOverrideItemAfter)
 {
     ASSERT(isHTMLSelectElement(select));
 }
 
     : HTMLCollection(select, SelectOptions, DoesNotOverrideItemAfter)
 {
     ASSERT(isHTMLSelectElement(select));
 }
 
-PassRefPtr<HTMLOptionsCollection> HTMLOptionsCollection::create(Node* select, CollectionType)
+PassRefPtr<HTMLOptionsCollection> HTMLOptionsCollection::create(Node& select, CollectionType)
 {
     return adoptRef(new HTMLOptionsCollection(select));
 }
 {
     return adoptRef(new HTMLOptionsCollection(select));
 }
@@ -58,39 +58,39 @@ void HTMLOptionsCollection::add(PassRefPtr<HTMLOptionElement> element, int index
     }
 
     ec = 0;
     }
 
     ec = 0;
-    HTMLSelectElement* select = toHTMLSelectElement(ownerNode());
+    HTMLSelectElement& select = toHTMLSelectElement(ownerNode());
 
     if (index == -1 || unsigned(index) >= length())
 
     if (index == -1 || unsigned(index) >= length())
-        select->add(newOption, 0, ec);
+        select.add(newOption, 0, ec);
     else
     else
-        select->add(newOption, toHTMLOptionElement(item(index)), ec);
+        select.add(newOption, toHTMLOptionElement(item(index)), ec);
 
     ASSERT(!ec);
 }
 
 void HTMLOptionsCollection::remove(int index)
 {
 
     ASSERT(!ec);
 }
 
 void HTMLOptionsCollection::remove(int index)
 {
-    toHTMLSelectElement(ownerNode())->removeByIndex(index);
+    toHTMLSelectElement(ownerNode()).removeByIndex(index);
 }
 
 void HTMLOptionsCollection::remove(HTMLOptionElement* option)
 {
 }
 
 void HTMLOptionsCollection::remove(HTMLOptionElement* option)
 {
-    toHTMLSelectElement(ownerNode())->remove(option);
+    toHTMLSelectElement(ownerNode()).remove(option);
 }
 
 int HTMLOptionsCollection::selectedIndex() const
 {
 }
 
 int HTMLOptionsCollection::selectedIndex() const
 {
-    return toHTMLSelectElement(ownerNode())->selectedIndex();
+    return toHTMLSelectElement(ownerNode()).selectedIndex();
 }
 
 void HTMLOptionsCollection::setSelectedIndex(int index)
 {
 }
 
 void HTMLOptionsCollection::setSelectedIndex(int index)
 {
-    toHTMLSelectElement(ownerNode())->setSelectedIndex(index);
+    toHTMLSelectElement(ownerNode()).setSelectedIndex(index);
 }
 
 void HTMLOptionsCollection::setLength(unsigned length, ExceptionCode& ec)
 {
 }
 
 void HTMLOptionsCollection::setLength(unsigned length, ExceptionCode& ec)
 {
-    toHTMLSelectElement(ownerNode())->setLength(length, ec);
+    toHTMLSelectElement(ownerNode()).setLength(length, ec);
 }
 
 } //namespace
 }
 
 } //namespace
index 8579979758376c108b4b2e04402e15c311842599..e04ecc28f58131957c1803cdaf2dcc25066b52bf 100644 (file)
@@ -35,7 +35,7 @@ typedef int ExceptionCode;
 
 class HTMLOptionsCollection : public HTMLCollection {
 public:
 
 class HTMLOptionsCollection : public HTMLCollection {
 public:
-    static PassRefPtr<HTMLOptionsCollection> create(Node*, CollectionType);
+    static PassRefPtr<HTMLOptionsCollection> create(Node&, CollectionType);
 
     void add(PassRefPtr<HTMLOptionElement>, ExceptionCode&);
     void add(PassRefPtr<HTMLOptionElement>, int index, ExceptionCode&);
 
     void add(PassRefPtr<HTMLOptionElement>, ExceptionCode&);
     void add(PassRefPtr<HTMLOptionElement>, int index, ExceptionCode&);
@@ -48,7 +48,7 @@ public:
     void setLength(unsigned, ExceptionCode&);
 
 private:
     void setLength(unsigned, ExceptionCode&);
 
 private:
-    HTMLOptionsCollection(Node*);
+    explicit HTMLOptionsCollection(Node&);
 };
 
 } //namespace
 };
 
 } //namespace
index 246852a2296f0700c456621412b30dc50af18e76..844494e59187fa6de49c671c9c8c3d4842bbc2f9 100644 (file)
@@ -147,12 +147,12 @@ HTMLTableRowElement* HTMLTableRowsCollection::lastRow(HTMLTableElement* table)
     return 0;
 }
 
     return 0;
 }
 
-HTMLTableRowsCollection::HTMLTableRowsCollection(HTMLTableElement* table)
+HTMLTableRowsCollection::HTMLTableRowsCollection(HTMLTableElement& table)
     : HTMLCollection(table, TableRows, OverridesItemAfter)
 {
 }
 
     : HTMLCollection(table, TableRows, OverridesItemAfter)
 {
 }
 
-PassRefPtr<HTMLTableRowsCollection> HTMLTableRowsCollection::create(Node* table, CollectionType type)
+PassRefPtr<HTMLTableRowsCollection> HTMLTableRowsCollection::create(Node& table, CollectionType type)
 {
     ASSERT_UNUSED(type, type == TableRows);
     return adoptRef(new HTMLTableRowsCollection(toHTMLTableElement(table)));
 {
     ASSERT_UNUSED(type, type == TableRows);
     return adoptRef(new HTMLTableRowsCollection(toHTMLTableElement(table)));
@@ -161,7 +161,7 @@ PassRefPtr<HTMLTableRowsCollection> HTMLTableRowsCollection::create(Node* table,
 Element* HTMLTableRowsCollection::virtualItemAfter(unsigned& offsetInArray, Element* previous) const
 {
     ASSERT_UNUSED(offsetInArray, !offsetInArray);
 Element* HTMLTableRowsCollection::virtualItemAfter(unsigned& offsetInArray, Element* previous) const
 {
     ASSERT_UNUSED(offsetInArray, !offsetInArray);
-    return rowAfter(toHTMLTableElement(ownerNode()), toHTMLTableRowElement(previous));
+    return rowAfter(&toHTMLTableElement(ownerNode()), toHTMLTableRowElement(previous));
 }
 
 }
 }
 
 }
index f225cf3750764f23b3fecdad61ea72ea24ab6755..91fe4358fedab0149196f546691616a18afdcf0d 100644 (file)
@@ -38,13 +38,13 @@ class HTMLTableRowElement;
 
 class HTMLTableRowsCollection FINAL : public HTMLCollection {
 public:
 
 class HTMLTableRowsCollection FINAL : public HTMLCollection {
 public:
-    static PassRefPtr<HTMLTableRowsCollection> create(Node*, CollectionType);
+    static PassRefPtr<HTMLTableRowsCollection> create(Node&, CollectionType);
 
     static HTMLTableRowElement* rowAfter(HTMLTableElement*, HTMLTableRowElement*);
     static HTMLTableRowElement* lastRow(HTMLTableElement*);
 
 private:
 
     static HTMLTableRowElement* rowAfter(HTMLTableElement*, HTMLTableRowElement*);
     static HTMLTableRowElement* lastRow(HTMLTableElement*);
 
 private:
-    explicit HTMLTableRowsCollection(HTMLTableElement*);
+    explicit HTMLTableRowsCollection(HTMLTableElement&);
 
     virtual Element* virtualItemAfter(unsigned& offsetInArray, Element*) const OVERRIDE;
 };
 
     virtual Element* virtualItemAfter(unsigned& offsetInArray, Element*) const OVERRIDE;
 };
index 012022d3d22d04f35b3ddb0be822c152442a115f..ee5fde8a16fc03f1fed6ae531badcfc9a0ea22c0 100644 (file)
@@ -45,7 +45,7 @@ PassRefPtr<NodeList> LabelableElement::labels()
     if (!supportLabels())
         return 0;
 
     if (!supportLabels())
         return 0;
 
-    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<LabelsNodeList>(this, LabelsNodeListType, starAtom);
+    return ensureRareData().ensureNodeLists().addCacheWithAtomicName<LabelsNodeList>(*this, LabelsNodeListType, starAtom);
 }
 
 } // namespace Webcore
 }
 
 } // namespace Webcore
index f654761cc75bbeac7dd471cab28925efbcf3147a..f4bf6ca46bcd6165ddd916259045ea6310d5dea9 100644 (file)
@@ -33,19 +33,19 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
 
 using namespace HTMLNames;
 
-LabelsNodeList::LabelsNodeList(Node* forNode)
+LabelsNodeList::LabelsNodeList(Node& forNode)
     : LiveNodeList(forNode, LabelsNodeListType, InvalidateOnForAttrChange, NodeListIsRootedAtDocument)
 {
 }
 
 LabelsNodeList::~LabelsNodeList()
 {
     : LiveNodeList(forNode, LabelsNodeListType, InvalidateOnForAttrChange, NodeListIsRootedAtDocument)
 {
 }
 
 LabelsNodeList::~LabelsNodeList()
 {
-    ownerNode()->nodeLists()->removeCacheWithAtomicName(this, LabelsNodeListType, starAtom);
+    ownerNode().nodeLists()->removeCacheWithAtomicName(this, LabelsNodeListType, starAtom);
 } 
     
 bool LabelsNodeList::nodeMatches(Element* testNode) const
 {
 } 
     
 bool LabelsNodeList::nodeMatches(Element* testNode) const
 {
-    return isHTMLLabelElement(testNode) && toHTMLLabelElement(testNode)->control() == ownerNode();
+    return isHTMLLabelElement(testNode) && toHTMLLabelElement(testNode)->control() == &ownerNode();
 }
 
 } // namespace WebCore
 }
 
 } // namespace WebCore
index 0da4f3c7e65bdcd553e408fe27a0cb42be484a91..e4f875fadb12911f2760fa5c2f3c7144ffade0a5 100644 (file)
@@ -32,7 +32,7 @@ namespace WebCore {
 
 class LabelsNodeList : public LiveNodeList {
 public:
 
 class LabelsNodeList : public LiveNodeList {
 public:
-    static PassRefPtr<LabelsNodeList> create(Node* forNode, CollectionType type, const AtomicString&)
+    static PassRefPtr<LabelsNodeList> create(Node& forNode, CollectionType type, const AtomicString&)
     {
         ASSERT_UNUSED(type, type == LabelsNodeListType);
         return adoptRef(new LabelsNodeList(forNode));
     {
         ASSERT_UNUSED(type, type == LabelsNodeListType);
         return adoptRef(new LabelsNodeList(forNode));
@@ -40,7 +40,7 @@ public:
     ~LabelsNodeList();
 
 protected:
     ~LabelsNodeList();
 
 protected:
-    LabelsNodeList(Node* forNode);
+    explicit LabelsNodeList(Node& forNode);
 
     virtual bool nodeMatches(Element*) const;
 };
 
     virtual bool nodeMatches(Element*) const;
 };
index 4abeb65e567d35117b7ae15f9192dc00dcbfa11c..1249702263f87c521a4f313a5bdc883ef8ea46e4 100644 (file)
@@ -37,7 +37,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
 
 using namespace HTMLNames;
 
-RadioNodeList::RadioNodeList(Node* rootNode, const AtomicString& name)
+RadioNodeList::RadioNodeList(Node& rootNode, const AtomicString& name)
     : LiveNodeList(rootNode, RadioNodeListType, InvalidateForFormControls, isHTMLFormElement(rootNode) ? NodeListIsRootedAtDocument : NodeListIsRootedAtNode)
     , m_name(name)
 {
     : LiveNodeList(rootNode, RadioNodeListType, InvalidateForFormControls, isHTMLFormElement(rootNode) ? NodeListIsRootedAtDocument : NodeListIsRootedAtNode)
     , m_name(name)
 {
@@ -45,7 +45,7 @@ RadioNodeList::RadioNodeList(Node* rootNode, const AtomicString& name)
 
 RadioNodeList::~RadioNodeList()
 {
 
 RadioNodeList::~RadioNodeList()
 {
-    ownerNode()->nodeLists()->removeCacheWithAtomicName(this, RadioNodeListType, m_name);
+    ownerNode().nodeLists()->removeCacheWithAtomicName(this, RadioNodeListType, m_name);
 }
 
 static inline HTMLInputElement* toRadioButtonInputElement(Node* node)
 }
 
 static inline HTMLInputElement* toRadioButtonInputElement(Node* node)
@@ -90,7 +90,7 @@ bool RadioNodeList::checkElementMatchesRadioNodeListFilter(Element* testElement)
             formElement = static_cast<HTMLObjectElement*>(testElement)->form();
         else
             formElement = static_cast<HTMLFormControlElement*>(testElement)->form();
             formElement = static_cast<HTMLObjectElement*>(testElement)->form();
         else
             formElement = static_cast<HTMLFormControlElement*>(testElement)->form();
-        if (!formElement || formElement != ownerNode())
+        if (!formElement || formElement != &ownerNode())
             return false;
     }
 
             return false;
     }
 
index 6845ca79334e27ddc6d53afb961ddb0beb3fa4be..92eddac0290d07d1b5a0e297b13a1664e02a01cc 100644 (file)
@@ -34,7 +34,7 @@ namespace WebCore {
 
 class RadioNodeList : public LiveNodeList {
 public:
 
 class RadioNodeList : public LiveNodeList {
 public:
-    static PassRefPtr<RadioNodeList> create(Node* rootNode, CollectionType type, const AtomicString& name)
+    static PassRefPtr<RadioNodeList> create(Node& rootNode, CollectionType type, const AtomicString& name)
     {
         ASSERT_UNUSED(type, type == RadioNodeListType);
         return adoptRef(new RadioNodeList(rootNode, name));
     {
         ASSERT_UNUSED(type, type == RadioNodeListType);
         return adoptRef(new RadioNodeList(rootNode, name));
@@ -49,7 +49,7 @@ protected:
     virtual bool nodeMatches(Element*) const;
 
 private:
     virtual bool nodeMatches(Element*) const;
 
 private:
-    RadioNodeList(Node*, const AtomicString& name);
+    RadioNodeList(Node&, const AtomicString& name);
     bool checkElementMatchesRadioNodeListFilter(Element*) const;
 
     AtomicString m_name;
     bool checkElementMatchesRadioNodeListFilter(Element*) const;
 
     AtomicString m_name;