Unify HTMLCollection and DynamicNodeList
[WebKit-https.git] / Source / WebCore / html / HTMLPropertiesCollection.cpp
1 /*
2  * Copyright (c) 2011 Motorola Mobility, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without modification,
5  * are permitted provided that the following conditions are met:
6  *
7  * Redistributions of source code must retain the above copyright notice,
8  * this list of conditions and the following disclaimer.
9  *
10  * Redistributions in binary form must reproduce the above copyright notice,
11  * this list of conditions and the following disclaimer in the documentation and/or
12  * other materials provided with the distribution.
13  *
14  * Neither the name of Motorola Mobility, Inc. nor the names of its contributors may
15  * be used to endorse or promote products derived from this software without
16  * specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #if ENABLE(MICRODATA)
34
35 #include "HTMLPropertiesCollection.h"
36
37 #include "DOMSettableTokenList.h"
38 #include "DOMStringList.h"
39 #include "HTMLElement.h"
40 #include "HTMLNames.h"
41 #include "Node.h"
42 #include "StaticNodeList.h"
43
44 namespace WebCore {
45
46 using namespace HTMLNames;
47
48 PassRefPtr<HTMLPropertiesCollection> HTMLPropertiesCollection::create(Node* itemNode)
49 {
50     return adoptRef(new HTMLPropertiesCollection(itemNode));
51 }
52
53 HTMLPropertiesCollection::HTMLPropertiesCollection(Node* itemNode)
54     : HTMLCollection(itemNode, ItemProperties, OverridesItemAfter)
55     , m_hasPropertyNameCache(false)
56     , m_hasItemRefElements(false)
57 {
58 }
59
60 HTMLPropertiesCollection::~HTMLPropertiesCollection()
61 {
62 }
63
64 void HTMLPropertiesCollection::updateRefElements() const
65 {
66     if (m_hasItemRefElements)
67         return;
68
69     HTMLElement* baseElement = toHTMLElement(base());
70
71     m_itemRefElements.clear();
72     m_hasItemRefElements = true;
73
74     if (!baseElement->fastHasAttribute(itemscopeAttr))
75         return;
76
77     if (!baseElement->fastHasAttribute(itemrefAttr)) {
78         m_itemRefElements.append(baseElement);
79         return;
80     }
81
82     DOMSettableTokenList* itemRef = baseElement->itemRef();
83     RefPtr<DOMSettableTokenList> processedItemRef = DOMSettableTokenList::create();
84     Node* rootNode = baseElement->treeScope()->rootNode();
85
86     for (Node* current = rootNode->firstChild(); current; current = current->traverseNextNode(rootNode)) {
87         if (!current->isHTMLElement())
88             continue;
89         HTMLElement* element = toHTMLElement(current);
90
91         if (element == baseElement) {
92             m_itemRefElements.append(element);
93             continue;
94         }
95
96         const AtomicString& id = element->getIdAttribute();
97         if (!processedItemRef->tokens().contains(id) && itemRef->tokens().contains(id)) {
98             processedItemRef->setValue(id);
99             if (!element->isDescendantOf(baseElement))
100                 m_itemRefElements.append(element);
101         }
102     }
103 }
104
105 static Node* nextNodeWithProperty(Node* base, Node* node)
106 {
107     // An Microdata item may contain properties which in turn are items themselves. Properties can
108     // also themselves be groups of name-value pairs, by putting the itemscope attribute on the element
109     // that declares the property. If the property has an itemscope attribute specified then we need
110     // to traverse the next sibling.
111     return node == base || (node->isHTMLElement() && !toHTMLElement(node)->fastHasAttribute(itemscopeAttr))
112             ? node->traverseNextNode(base) : node->traverseNextSibling(base);
113 }
114
115 Element* HTMLPropertiesCollection::virtualItemAfter(unsigned& offsetInArray, Element* previousItem) const
116 {
117     while (offsetInArray < m_itemRefElements.size()) {
118         if (Element* next = virtualItemAfter(m_itemRefElements[offsetInArray], previousItem))
119             return next;
120         offsetInArray++;
121         previousItem = 0;
122     }
123     return 0;
124 }
125
126 HTMLElement* HTMLPropertiesCollection::virtualItemAfter(HTMLElement* base, Element* previous) const
127 {
128     Node* current;
129     current = previous ? nextNodeWithProperty(base, previous) : base;
130
131     for (; current; current = nextNodeWithProperty(base, current)) {
132         if (!current->isHTMLElement())
133             continue;
134         HTMLElement* element = toHTMLElement(current);
135         if (element->fastHasAttribute(itempropAttr) && element->itemProp()->length()) {
136             return element;
137         }
138     }
139
140     return 0;
141 }
142
143 void HTMLPropertiesCollection::updateNameCache() const
144 {
145     if (m_hasPropertyNameCache)
146         return;
147
148     updateRefElements();
149
150     for (unsigned i = 0; i < m_itemRefElements.size(); ++i) {
151         HTMLElement* refElement = m_itemRefElements[i];
152         for (HTMLElement* element = virtualItemAfter(refElement, 0); element; element = virtualItemAfter(refElement, element)) {
153             DOMSettableTokenList* itemProperty = element->itemProp();
154             for (unsigned propertyIndex = 0; propertyIndex < itemProperty->length(); ++propertyIndex)
155                 updatePropertyCache(element, itemProperty->item(propertyIndex));
156         }
157     }
158
159     m_hasPropertyNameCache = true;
160 }
161
162 PassRefPtr<DOMStringList> HTMLPropertiesCollection::names() const
163 {
164     updateNameCache();
165     if (!m_propertyNames)
166         m_propertyNames = DOMStringList::create();
167     return m_propertyNames;
168 }
169
170 PassRefPtr<NodeList> HTMLPropertiesCollection::namedItem(const String& name) const
171 {
172     updateNameCache();
173
174     Vector<RefPtr<Node> > namedItems;
175     Vector<Element*>* propertyResults = m_propertyCache.get(AtomicString(name).impl());
176     for (unsigned i = 0; propertyResults && i < propertyResults->size(); ++i)
177         namedItems.append(propertyResults->at(i));
178
179     // FIXME: HTML5 specifies that this should return PropertyNodeList.
180     return namedItems.isEmpty() ? 0 : StaticNodeList::adopt(namedItems);
181 }
182
183 bool HTMLPropertiesCollection::hasNamedItem(const AtomicString& name) const
184 {
185     updateNameCache();
186
187     if (Vector<Element*>* propertyCache = m_propertyCache.get(name.impl())) {
188         if (!propertyCache->isEmpty())
189             return true;
190     }
191
192     return false;
193 }
194
195 } // namespace WebCore
196
197 #endif // ENABLE(MICRODATA)